void float2_param_t::value_changed( double value)
{
param_set()->begin_edit();
if( proportional_checked())
{
calc_proportional_factors();
Imath::V2f v = get_value<Imath::V2f>( *this);
if( sender() == input0_)
{
float inc = value - v.x;
v.x = value;
v.y = clamp( v.y + ( inc * proportional_factor.y));
}
else
{
float inc = value - v.y;
v.y = value;
v.x = clamp( v.x + ( inc * proportional_factor.x));
}
set_value( absolute_to_relative( Imath::V2f( round ( v.x), round( v.y))));
update_widgets();
}
else
set_value( absolute_to_relative( Imath::V2f( round (input0_->value()), round( input1_->value()))));
param_set()->end_edit();
}
void float2_param_t::spinbox_moved( double value)
{
if( proportional_checked())
{
Imath::V2f v = get_value<Imath::V2f>( *this);
if( sender() == input0_)
{
float inc = value - v.x;
v.x = value;
v.y = clamp( v.y + ( inc * proportional_factor.y));
}
else
{
float inc = value - v.y;
v.y = value;
v.x = clamp( v.x + ( inc * proportional_factor.x));
}
set_value( absolute_to_relative( Imath::V2f( round ( v.x), round( v.y))));
update_widgets();
}
else
set_value( absolute_to_relative( Imath::V2f( round (input0_->value()), round( input1_->value()))));
if( track_mouse())
param_set()->notify_parent();
ui::anim_editor_t::Instance().update();
}
void se_expr_param_t::expr_editor_accept( const std::string& new_expr)
{
param_set()->begin_edit();
set_value( new_expr);
param_set()->end_edit();
saved_expression_.clear();
update_widgets();
}
static GtkWidget * ad9739a_init(struct osc_plugin *plugin, GtkWidget *notebook, const char *ini_fn)
{
GtkBuilder *builder;
GtkWidget *ad9739a_panel;
GtkWidget *dds_container;
ctx = osc_create_context();
if (!ctx)
return NULL;
dac = iio_context_find_device(ctx, DAC_DEVICE);
dac_tx_manager = dac_data_manager_new(dac, NULL, ctx);
if (!dac_tx_manager) {
osc_destroy_context(ctx);
return NULL;
}
builder = gtk_builder_new();
if (osc_load_glade_file(builder, "ad9739a") < 0)
return NULL;
ad9739a_panel = GTK_WIDGET(gtk_builder_get_object(builder, "ad9739a_panel"));
dds_container = GTK_WIDGET(gtk_builder_get_object(builder, "dds_transmit_block"));
gtk_container_add(GTK_CONTAINER(dds_container), dac_data_manager_get_gui_container(dac_tx_manager));
gtk_widget_show_all(dds_container);
/* Bind the IIO device files to the GUI widgets */
iio_combo_box_init_from_builder(&tx_widgets[num_tx++],
dac, NULL, "operation_mode", "operation_modes_available",
builder, "operation_modes_combo", NULL);
iio_spin_button_int_init_from_builder(&tx_widgets[num_tx++],
dac, NULL, "full_scale_current", builder,
"full_scale_spin", NULL);
if (ini_fn)
load_profile(NULL, ini_fn);
/* Update all widgets with current values */
update_widgets();
make_widget_update_signal_based(tx_widgets, num_tx);
g_builder_connect_signal(builder, "ad9739a_settings_reload", "clicked",
G_CALLBACK(reload_button_clicked), NULL);
dac_data_manager_freq_widgets_range_update(dac_tx_manager, 2E15 / 2);
dac_data_manager_update_iio_widgets(dac_tx_manager);
dac_data_manager_set_buffer_chooser_current_folder(dac_tx_manager, OSC_WAVEFORM_FILE_PATH);
can_update_widgets = true;
return ad9739a_panel;
}
void
Update_Operator_Widgets (int op)
{
update_widgets (9, wave[op]);
update_widgets (10, H[op]);
update_widgets (11, HF[op]);
update_widgets (12, Ovol[op]);
update_widgets (13, attack[op]);
update_widgets (14, decay[op]);
update_widgets (15, sustain[op]);
update_widgets (16, release[op]);
update_widgets (17, pLFO[op]);
}
static void reload_button_clicked(GtkButton *btn, gpointer data)
{
update_widgets();
filter_fir_update();
rx_freq_info_update();
glb_settings_update_labels();
rssi_update_labels();
rx_phase_rotation_update();
}
void ColorDialog::setColorInternal(const QColor &c)
{
/**
* \note Unlike setColor, this is used to update the current color which
* migth differ from the final selected color
*/
p->ui.wheel->setColor(c);
p->ui.slide_alpha->setValue(c.alpha());
update_widgets();
}
void se_expr_param_t::expr_editor_cancel()
{
if( get_value<std::string>( *this) != saved_expression_)
{
set_value( saved_expression_, node_edited);
param_set()->notify_parent();
}
saved_expression_.clear();
update_widgets();
}
void ColorDialog::set_hsv()
{
if ( !signalsBlocked() )
{
p->ui.wheel->setColor(QColor::fromHsv(
p->ui.slide_hue->value(),
p->ui.slide_saturation->value(),
p->ui.slide_value->value()
));
update_widgets();
}
}
void image_format_param_t::preset_picked( int v)
{
if( v == image::format_t::presets().size())
return;
image::format_t new_format;
new_format.set_from_preset( v);
param_set()->begin_edit();
set_value( new_format);
param_set()->end_edit();
update_widgets();
}
int
control_handler (const char *path, const char *types, lo_arg ** argv,
int argc, void *data, void *user_data)
{
if (argc < 2)
{
printf ("Error: too few arguments to control_handler\n");
return 1;
}
const int port = argv[0]->i;
const float value = argv[1]->f;
if ((port < 9) || (port > 62))
update_widgets (port, value);
else if (port < 63)
update_widgets (((port + 3) / 6) + 7, value);
return 0;
}
void
preferences_show (void)
{
if (dialog == NULL)
{
glade_xml = glade_xml_new(g_build_filename(MINBAR_DATADIR,GLADE_MAIN_INTERFACE,NULL), NULL, NULL);
glade_xml_signal_autoconnect(glade_xml);
dialog = glade_xml_get_widget(glade_xml, "editcity");
setup_dialog();
update_widgets();
}
gtk_window_present(GTK_WINDOW(dialog));
}
void ColorDialog::set_rgb()
{
if ( !signalsBlocked() )
{
QColor col(
p->ui.slide_red->value(),
p->ui.slide_green->value(),
p->ui.slide_blue->value()
);
if (col.saturation() == 0)
col = QColor::fromHsv(p->ui.slide_hue->value(), 0, col.value());
p->ui.wheel->setColor(col);
update_widgets();
}
}
void corner_pin_node_t::param_changed( param_t *p, param_t::change_reason reason)
{
RAMEN_ASSERT( composition());
if( reason == param_t::user_edited && p == ¶m( "apply_track"))
{
const tracker_node_t *tracker = ui::apply_corner_track_dialog_t::instance().exec();
if( tracker)
{
float2_param_t *topleft = dynamic_cast<float2_param_t*>( ¶m( "topleft"));
float2_param_t *topright = dynamic_cast<float2_param_t*>( ¶m( "topright"));
float2_param_t *botleft = dynamic_cast<float2_param_t*>( ¶m( "botleft"));
float2_param_t *botright = dynamic_cast<float2_param_t*>( ¶m( "botright"));
float start_frame = composition()->start_frame();
float end_frame = composition()->end_frame();
param_set().begin_edit();
for( float frame = start_frame; frame <= end_frame; frame += 1.0f)
{
boost::optional<Imath::V2f> p = tracker->tracker_pos( 0, frame);
if( p)
topleft->set_absolute_value_at_frame( p.get(), frame);
p = tracker->tracker_pos( 1, frame);
if( p)
topright->set_absolute_value_at_frame( p.get(), frame);
p = tracker->tracker_pos( 2, frame);
if( p)
botright->set_absolute_value_at_frame( p.get(), frame);
p = tracker->tracker_pos( 3, frame);
if( p)
botleft->set_absolute_value_at_frame( p.get(), frame);
}
param_set().end_edit();
update_widgets();
}
}
}
static void load_profile(const char *ini_fn)
{
char *value;
update_from_ini(ini_fn, THIS_DRIVER, dev,
fmcomms2_adv_sr_attribs,
ARRAY_SIZE(fmcomms2_adv_sr_attribs));
if (can_update_widgets)
update_widgets(builder);
value = read_token_from_ini(ini_fn, THIS_DRIVER, "calibrate");
if (value) {
fmcomms2adv_handle_driver("calibrate", value);
free(value);
}
}
void float2_param_t::do_domain_changed( const Imath::Box2i& new_domain)
{
if( input0_)
{
input0_->blockSignals( true);
input1_->blockSignals( true);
input0_->setRange( absolute_min(), absolute_max());
input1_->setRange( absolute_min(), absolute_max());
input0_->blockSignals( false);
input1_->blockSignals( false);
update_widgets();
}
}
void introduce_dialog::introduce()
{
INVARIANT(_user_service);
INVARIANT(_user_service);
INVARIANT(_contact_1);
INVARIANT(_contact_2);
INVARIANT(_message_1);
INVARIANT(_message_2);
auto c1 = _contact_1->selected_contact();
auto c2 = _contact_2->selected_contact();
if(!c1 || !c2)
{
update_widgets();
return;
}
CHECK(c1);
CHECK(c2);
//validate that they want to introduce the two selected
std::stringstream msg;
msg << convert(tr("Are you sure you want to introduce `")) << c1->name() << convert(tr("' to `")) << c2->name() << "'?";
auto a = QMessageBox::warning(this, tr("Introduce"), msg.str().c_str(), QMessageBox::Yes | QMessageBox::No);
if(a != QMessageBox::Yes) return;
std::string GREETER = ""; //TODO SET THIS
us::contact_introduction i1{
_user_service->user().info().id(),
GREETER,
convert(_message_1->text()),
*c2
};
us::contact_introduction i2{
_user_service->user().info().id(),
GREETER,
convert(_message_2->text()),
*c1
};
_user_service->send_introduction(c1->id(), i1);
_user_service->send_introduction(c2->id(), i2);
accept();
}
void filter_fir_enable(GtkToggleButton *button, gpointer data)
{
bool rx, tx, rxtx, disable;
if (gtk_toggle_button_get_active(button))
return;
rx = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (enable_fir_filter_rx));
tx = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (fir_filter_en_tx));
rxtx = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (enable_fir_filter_rx_tx));
disable = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (disable_all_fir_filters));
if (rxtx || disable) {
iio_device_attr_write_bool(dev,
"in_out_voltage_filter_fir_en", rxtx);
} else {
struct iio_channel *chn;
if (rx) {
chn = iio_device_find_channel(dev, "voltage0", true);
if (chn)
iio_channel_attr_write_bool(chn, "filter_fir_en", tx);
chn = iio_device_find_channel(dev, "voltage0", false);
if (chn)
iio_channel_attr_write_bool(chn, "filter_fir_en", rx);
}
if (tx) {
chn = iio_device_find_channel(dev, "voltage0", false);
if (chn)
iio_channel_attr_write_bool(chn, "filter_fir_en", rx);
chn = iio_device_find_channel(dev, "voltage0", true);
if (chn)
iio_channel_attr_write_bool(chn, "filter_fir_en", tx);
}
}
filter_fir_update();
glb_settings_update_labels();
update_widgets();
rx_freq_info_update();
}
void generic_sys_coordinator::on_animation_update()
{
if(m_request_termination)
{
return;
}
auto drawer = static_cast< rtp::animated_system_drawer* >(m_widget->get_drawer());
// Advance animation state
auto result = drawer->advance();
switch(result)
{
case rtp::animated_system_drawer::Result::Ongoing:
// Draw
update_widgets();
// And schedule next frame
m_timer.expires_at(m_timer.expires_at() + boost::posix_time::milliseconds(1000.0f / AnimationFreq));
m_timer.async_wait(boost::bind(&generic_sys_coordinator::on_animation_update, this));
break;
case rtp::animated_system_drawer::Result::Finished:
{
switch(m_system_st)
{
case SystemState::Active:
// m_timer.expires_at(m_timer.expires_at() + boost::posix_time::milliseconds(1000.0f / AnimationFreq /* TODO: immediate??? */));
// m_timer.async_wait(boost::bind(&generic_sys_coordinator::on_system_update, this));
on_system_update();
break;
case SystemState::Completed:
// All done
if(m_finish_cb)
{
m_finish_cb();
}
break;
}
}
break;
}
}
int update_multitrack_widgets( void *data, int *array, int track )
{
multitracker_t *mt = (multitracker_t*) data;
sequence_view_t *p = mt->view[ track ];
p->status_lock = 1;
int pm = array[PLAY_MODE];
int i;
for( i = 0; i < 20; i ++ )
p->status_cache[i] = array[i];
update_widgets(array, p, pm);
int *his = p->history[ pm ];
for( i = 0; i < 20; i ++ )
his[i] = array[i];
p->status_lock = 0;
return 1;
}
void GVControlsWidget::on_combo_changed(QWidget* control)
{
GVComboBox* combobox = (GVComboBox*) control;
int val = combobox->currentIndex();
int index = combobox->get_index();
dev->listControls[index].value = val;
if(!(dev->set_control_val (index)))
{
std::cout << dev->listControls[index].control.name
<< " = " << dev->listControls[index].value << std::endl;
}
else
{
std::cerr << "ERROR:couldn't set " << dev->listControls[index].control.name
<< " = " << val << std::endl;
combobox->blockSignals(true);
combobox->setCurrentIndex(dev->listControls[index].value);
combobox->blockSignals(false);
}
update_widgets();
}
void GVControlsWidget::on_check_button_clicked(QWidget* control)
{
GVCheckBox* checkbox = (GVCheckBox*) control;
int val = checkbox->isChecked() ? 1 : 0;
int index = checkbox->get_index();
dev->listControls[index].value = val;
if(!(dev->set_control_val (index)))
{
std::cout << dev->listControls[index].control.name << " = " <<
dev->listControls[index].value << std::endl;
}
else
{
std::cerr << "ERROR:couldn't set " << dev->listControls[index].control.name
<< " = " << val << std::endl;
checkbox->blockSignals(true);
if(dev->listControls[index].value) checkbox->setChecked(true);
else checkbox->setChecked(false);
checkbox->blockSignals(false);
}
update_widgets();
}
void generic_sys_coordinator::restart()
{
terminate_system();
m_sys = m_sys_factory->create_system();
m_sys->initialize();
rtp::interactive_input_set all_inputs;
for(auto const& agent : m_agents_spec.agents)
{
auto agent_id = m_sys->register_agent(agent.spec);
auto& factory = m_agents_spec.controller_factories[agent.controller_id];
auto controller = std::unique_ptr< rtp::i_controller >(
factory->create(&m_sys->get_agent(agent_id))
);
if(factory->is_interactive())
{
auto interactive = static_cast<rtp::i_interactive_controller*>(controller.get());
auto const& required_inputs = interactive->get_required_interactive_inputs();
all_inputs.insert(required_inputs.begin(), required_inputs.end());
}
m_sys->register_agent_controller(agent_id, std::move(controller));
}
/////
m_widget->set_drawer(m_sys->get_drawer());
m_widget->enable_interaction(all_inputs);
m_props_widget->clear_content();
//m_props_widget->reset(m_sys->get_state_properties());
m_system_st = SystemState::Active;
m_step = 0;
m_avg_update_period = 0.0f;
// TODO: Set focus???? m_widget->clicked().emit(Wt::WMouseEvent());
auto uinf = m_sys->get_update_info();
bool instant = m_sys->is_instantaneous();
bool realtime = uinf.type == rtp::i_system::update_info::Type::Realtime;
bool animated = !realtime && m_widget->get_drawer()->is_animated();
auto delay = instant ?
0.0 :
(
realtime ?
(1.0 / uinf.frequency) :
(
animated ?
(1.0 / AnimationFreq) :
(1.0 / NonRealtimeFreq)
)
);
m_io.reset();
m_timer.expires_from_now(boost::posix_time::milliseconds(1000.0f * delay));
if(animated)
{
auto anim_drawer = static_cast<rtp::animated_system_drawer*>(m_widget->get_drawer());
anim_drawer->start();
m_timer.async_wait(boost::bind(&generic_sys_coordinator::on_animation_update, this));
}
else
{
m_timer.async_wait(boost::bind(&generic_sys_coordinator::on_system_update, this));
}
std::thread t(boost::bind(&boost::asio::io_service::run, &m_io));
m_update_thread.swap(t);
m_ready_to_display = !instant;
update_widgets();
}
void
Update_Main_Widgets ()
{
update_widgets (2, master_volume);
update_widgets (3, tune);
update_widgets (4, portamento);
update_widgets (5, LFO_Volume);
update_widgets (6, LFO_Frequency);
update_widgets (7, LFO_Delay);
update_widgets (8, LFO_Wave);
update_widgets (63, Ftype);
update_widgets (64, Fgain);
update_widgets (65, Fcutoff);
update_widgets (66, Fq);
update_widgets (67, FLFO);
update_widgets (68, FADSR);
update_widgets (69, Fstages);
update_widgets (70, Fvelocity);
update_widgets (71, algo);
}
static GtkWidget *create_editor_widgets(radio_conf_t * conf)
{
GtkWidget *table;
GtkWidget *label;
table = gtk_grid_new();
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
gtk_grid_set_column_homogeneous(GTK_GRID(table), FALSE);
gtk_grid_set_row_homogeneous(GTK_GRID(table), FALSE);
gtk_grid_set_column_spacing(GTK_GRID(table), 5);
gtk_grid_set_row_spacing(GTK_GRID(table), 5);
/* Config name */
label = gtk_label_new(_("Name"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 0, 1, 1);
name = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(name), 25);
g_signal_connect(name, "changed", G_CALLBACK(name_changed), NULL);
gtk_widget_set_tooltip_text(name,
_("Enter a short name for this configuration, "
"e.g. IC910-1.\n"
"Allowed characters: "
"0..9, a..z, A..Z, - and _"));
gtk_grid_attach(GTK_GRID(table), name, 1, 0, 3, 1);
/* Host */
label = gtk_label_new(_("Host"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 1, 1, 1);
host = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(host), 50);
gtk_entry_set_text(GTK_ENTRY(host), "localhost");
gtk_widget_set_tooltip_text(host,
_("Enter the host where rigctld is running. "
"You can use both host name and IP address, "
"e.g. 192.168.1.100\n\n"
"If gpredict and rigctld are running on the "
"same computer use localhost"));
gtk_grid_attach(GTK_GRID(table), host, 1, 1, 3, 1);
/* port */
label = gtk_label_new(_("Port"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 2, 1, 1);
port = gtk_spin_button_new_with_range(1024, 65535, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(port), 4532);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(port), 0);
gtk_widget_set_tooltip_text(port,
_("Enter the port number where rigctld is "
"listening"));
gtk_grid_attach(GTK_GRID(table), port, 1, 2, 1, 1);
/* radio type */
label = gtk_label_new(_("Radio type"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
//gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4);
gtk_grid_attach(GTK_GRID(table), label, 0, 3, 1, 1);
type = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type), _("RX only"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type), _("TX only"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type), _("Simplex TRX"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type), _("Duplex TRX"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type),
_("FT817/857/897 (auto)"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type),
_("FT817/857/897 (manual)"));
gtk_combo_box_set_active(GTK_COMBO_BOX(type), RIG_TYPE_RX);
g_signal_connect(type, "changed", G_CALLBACK(type_changed), NULL);
gtk_widget_set_tooltip_markup(type,
_("<b>RX only:</b> The radio shall only be "
"used as receiver. If <i>Monitor PTT "
"status</i> is checked the doppler tuning "
"will be suspended while PTT is ON "
"(manual TX). If not, the controller will "
"always perform doppler tuning and "
"you cannot use the same RIG for uplink.\n\n"
"<b>TX only:</b> The radio shall only be "
"used for uplink. If <i>Monitor PTT status</i>"
" is checked the doppler tuning will be "
"suspended while PTT is OFF (manual RX).\n\n"
"<b>Simplex TRX:</b> The radio should be "
"used for both up- and downlink but in "
"simplex mode only. This option requires "
"that the PTT status is monitored (otherwise "
"gpredict cannot know whether to tune the "
"RX or the TX).\n\n"
"<b>Duplex:</b> The radio is a full duplex "
"radio, such as the IC910H. Gpredict will "
"be continuously tuning both uplink and "
"downlink simultaneously and not care about "
"PTT setting.\n\n"
"<b>FT817/857/897 (auto):</b> "
"This is a special mode that can be used with "
"YAESU FT-817, 857 and 897 radios. These radios"
" do not allow computer control while in TX mode."
" Therefore, TX Doppler correction is applied "
"while the radio is in RX mode by toggling "
"between VFO A/B.\n\n"
"<b>FT817/857/897 (manual):</b> "
"This is similar to the previous mode except"
" that switching to TX is done by pressing the"
" SPACE key on the keyboard. Gpredict will "
"then update the TX Doppler before actually"
" switching to TX."));
gtk_grid_attach(GTK_GRID(table), type, 1, 3, 2, 1);
/* ptt */
label = gtk_label_new(_("PTT status"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 4, 1, 1);
ptt = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(ptt), _("None"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(ptt), _("Read PTT"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(ptt), _("Read DCD"));
gtk_combo_box_set_active(GTK_COMBO_BOX(ptt), 0);
g_signal_connect(ptt, "changed", G_CALLBACK(ptt_changed), NULL);
gtk_widget_set_tooltip_markup(ptt,
_("Select PTT type.\n\n"
"<b>None:</b>\nDon't read PTT status from this radio.\n\n"
"<b>Read PTT:</b>\nRead PTT status using get_ptt CAT command. "
"You have to check that your radio and hamlib supports this.\n\n"
"<b>Read DCD:</b>\nRead PTT status using get_dcd command. "
"This can be used if your radio does not support the read_ptt "
"CAT command and you have a special interface that can "
"read squelch status and send it via CTS."));
gtk_grid_attach(GTK_GRID(table), ptt, 1, 4, 2, 1);
/* VFO Up/Down */
label = gtk_label_new(_("VFO Up/Down"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 5, 1, 1);
vfo = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vfo), _("Not applicable"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vfo),
_("MAIN \342\206\221 / SUB \342\206\223"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vfo),
_("SUB \342\206\221 / MAIN \342\206\223"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vfo),
_("A \342\206\221 / B \342\206\223"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vfo),
_("B \342\206\221 / A \342\206\223"));
gtk_combo_box_set_active(GTK_COMBO_BOX(vfo), 0);
g_signal_connect(vfo, "changed", G_CALLBACK(vfo_changed), NULL);
gtk_widget_set_tooltip_markup(vfo,
_
("Select which VFO to use for uplink and downlink. "
"This setting is used for full-duplex radios only, "
"such as the IC-910H, FT-847 and the TS-2000.\n\n"
"<b>IC-910H:</b> MAIN\342\206\221 / SUB\342\206\223\n"
"<b>FT-847:</b> SUB\342\206\221 / MAIN\342\206\223\n"
"<b>TS-2000:</b> B\342\206\221 / A\342\206\223"));
gtk_grid_attach(GTK_GRID(table), vfo, 1, 5, 2, 1);
/* Downconverter LO frequency */
label = gtk_label_new(_("LO Down"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 6, 1, 1);
lo = gtk_spin_button_new_with_range(-10000, 10000, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(lo), 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(lo), 0);
gtk_widget_set_tooltip_text(lo,
_
("Enter the frequency of the local oscillator "
" of the downconverter, if any."));
gtk_grid_attach(GTK_GRID(table), lo, 1, 6, 2, 1);
label = gtk_label_new(_("MHz"));
g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 3, 6, 1, 1);
/* Upconverter LO frequency */
label = gtk_label_new(_("LO Up"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 7, 1, 1);
loup = gtk_spin_button_new_with_range(-10000, 10000, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(loup), 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(loup), 0);
gtk_widget_set_tooltip_text(loup,
_
("Enter the frequency of the local oscillator "
"of the upconverter, if any."));
gtk_grid_attach(GTK_GRID(table), loup, 1, 7, 2, 1);
label = gtk_label_new(_("MHz"));
g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 3, 7, 1, 1);
/* AOS / LOS signalling */
label = gtk_label_new(_("Signalling"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 8, 1, 1);
sigaos = gtk_check_button_new_with_label(_("AOS"));
gtk_grid_attach(GTK_GRID(table), sigaos, 1, 8, 1, 1);
gtk_widget_set_tooltip_text(sigaos,
_("Enable AOS signalling for this radio."));
siglos = gtk_check_button_new_with_label(_("LOS"));
gtk_grid_attach(GTK_GRID(table), siglos, 2, 8, 1, 1);
gtk_widget_set_tooltip_text(siglos,
_("Enable LOS signalling for this radio."));
if (conf->name != NULL)
update_widgets(conf);
gtk_widget_show_all(table);
return table;
}
static GtkWidget * fmcomms2_init(GtkWidget *notebook, const char *ini_fn)
{
GtkBuilder *builder;
GtkWidget *dds_container;
struct iio_channel *ch0, *ch1;
can_update_widgets = false;
ctx = osc_create_context();
if (!ctx)
return NULL;
dev = iio_context_find_device(ctx, PHY_DEVICE);
dds = iio_context_find_device(ctx, DDS_DEVICE);
cap = iio_context_find_device(ctx, CAP_DEVICE);
udc_rx = iio_context_find_device(ctx, UDC_RX_DEVICE);
udc_tx = iio_context_find_device(ctx, UDC_TX_DEVICE);
has_udc_driver = (udc_rx && udc_tx);
ch0 = iio_device_find_channel(dev, "voltage0", false);
ch1 = iio_device_find_channel(dev, "voltage1", false);
dac_tx_manager = dac_data_manager_new(dds, NULL, ctx);
if (!dac_tx_manager) {
iio_context_destroy(ctx);
return NULL;
}
const char *env_freq_span = getenv("OSC_UPDN_FREQ_SPAN");
const char *env_freq_mix_sign = getenv("OSC_UPDN_FREQ_MIX_SIGN");
if(!env_freq_span) {
updn_freq_span = 2;
} else {
errno = 0;
updn_freq_span = g_strtod(env_freq_span, NULL);
if (errno)
updn_freq_span = 2;
}
if(!env_freq_mix_sign) {
updn_freq_mix_sign = 1;
} else {
if (!strncmp(env_freq_mix_sign, "-", 1))
updn_freq_mix_sign = -1;
else
updn_freq_mix_sign = 1;
}
builder = gtk_builder_new();
nbook = GTK_NOTEBOOK(notebook);
if (!gtk_builder_add_from_file(builder, "fmcomms2.glade", NULL))
gtk_builder_add_from_file(builder, OSC_GLADE_FILE_PATH "fmcomms2.glade", NULL);
is_2rx_2tx = ch1 && iio_channel_find_attr(ch1, "hardwaregain");
fmcomms2_panel = GTK_WIDGET(gtk_builder_get_object(builder, "fmcomms2_panel"));
/* Global settings */
ensm_mode = GTK_WIDGET(gtk_builder_get_object(builder, "ensm_mode"));
ensm_mode_available = GTK_WIDGET(gtk_builder_get_object(builder, "ensm_mode_available"));
calib_mode = GTK_WIDGET(gtk_builder_get_object(builder, "calib_mode"));
calib_mode_available = GTK_WIDGET(gtk_builder_get_object(builder, "calib_mode_available"));
trx_rate_governor = GTK_WIDGET(gtk_builder_get_object(builder, "trx_rate_governor"));
trx_rate_governor_available = GTK_WIDGET(gtk_builder_get_object(builder, "trx_rate_governor_available"));
tx_path_rates = GTK_WIDGET(gtk_builder_get_object(builder, "label_tx_path"));
rx_path_rates = GTK_WIDGET(gtk_builder_get_object(builder, "label_rx_path"));
filter_fir_config = GTK_WIDGET(gtk_builder_get_object(builder, "filter_fir_config"));
enable_fir_filter_rx = GTK_WIDGET(gtk_builder_get_object(builder, "enable_fir_filter_rx"));
fir_filter_en_tx = GTK_WIDGET(gtk_builder_get_object(builder, "fir_filter_en_tx"));
enable_fir_filter_rx_tx = GTK_WIDGET(gtk_builder_get_object(builder, "enable_fir_filter_tx_rx"));
disable_all_fir_filters = GTK_WIDGET(gtk_builder_get_object(builder, "disable_all_fir_filters"));
up_down_converter = GTK_WIDGET(gtk_builder_get_object(builder, "checkbox_up_down_converter"));
section_toggle[SECTION_GLOBAL] = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builder, "global_settings_toggle"));
section_setting[SECTION_GLOBAL] = GTK_WIDGET(gtk_builder_get_object(builder, "global_settings"));
section_toggle[SECTION_TX] = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builder, "tx_toggle"));
section_setting[SECTION_TX] = GTK_WIDGET(gtk_builder_get_object(builder, "tx_settings"));
section_toggle[SECTION_RX] = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builder, "rx_toggle"));
section_setting[SECTION_RX] = GTK_WIDGET(gtk_builder_get_object(builder, "rx_settings"));
section_toggle[SECTION_FPGA] = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builder, "fpga_toggle"));
section_setting[SECTION_FPGA] = GTK_WIDGET(gtk_builder_get_object(builder, "fpga_settings"));
/* Receive Chain */
rf_port_select_rx = GTK_WIDGET(gtk_builder_get_object(builder, "rf_port_select_rx"));
rx_gain_control_rx1 = GTK_WIDGET(gtk_builder_get_object(builder, "gain_control_mode_rx1"));
rx_gain_control_rx2 = GTK_WIDGET(gtk_builder_get_object(builder, "gain_control_mode_rx2"));
rx_gain_control_modes_rx1 = GTK_WIDGET(gtk_builder_get_object(builder, "gain_control_mode_available_rx1"));
rx_gain_control_modes_rx2 = GTK_WIDGET(gtk_builder_get_object(builder, "gain_control_mode_available_rx2"));
rx1_rssi = GTK_WIDGET(gtk_builder_get_object(builder, "rssi_rx1"));
rx2_rssi = GTK_WIDGET(gtk_builder_get_object(builder, "rssi_rx2"));
rx_fastlock_profile = GTK_WIDGET(gtk_builder_get_object(builder, "rx_fastlock_profile"));
/* Transmit Chain */
rf_port_select_tx = GTK_WIDGET(gtk_builder_get_object(builder, "rf_port_select_tx"));
tx_fastlock_profile = GTK_WIDGET(gtk_builder_get_object(builder, "tx_fastlock_profile"));
tx1_rssi = GTK_WIDGET(gtk_builder_get_object(builder, "rssi_tx1"));
tx2_rssi = GTK_WIDGET(gtk_builder_get_object(builder, "rssi_tx2"));
dds_container = GTK_WIDGET(gtk_builder_get_object(builder, "dds_transmit_block"));
gtk_container_add(GTK_CONTAINER(dds_container), dac_data_manager_get_gui_container(dac_tx_manager));
gtk_widget_show_all(dds_container);
rx_phase_rotation[0] = GTK_WIDGET(gtk_builder_get_object(builder, "rx1_phase_rotation"));
rx_phase_rotation[1] = GTK_WIDGET(gtk_builder_get_object(builder, "rx2_phase_rotation"));
gtk_combo_box_set_active(GTK_COMBO_BOX(ensm_mode_available), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(trx_rate_governor_available), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(rx_gain_control_modes_rx1), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(rx_gain_control_modes_rx2), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(rf_port_select_rx), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(rf_port_select_tx), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(rx_fastlock_profile), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(tx_fastlock_profile), 0);
/* Set FMCOMMS2/3 max sampling freq -> 61.44MHz and FMCOMMS4 -> 122.88 */
GtkWidget *sfreq = GTK_WIDGET(gtk_builder_get_object(builder, "sampling_freq_tx"));
GtkAdjustment *sfreq_adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(sfreq));
if (is_2rx_2tx)
gtk_adjustment_set_upper(sfreq_adj, 61.44);
else
gtk_adjustment_set_upper(sfreq_adj, 122.88);
/* Bind the IIO device files to the GUI widgets */
glb_widgets = widgets;
/* Global settings */
iio_combo_box_init(&glb_widgets[num_glb++],
dev, NULL, "ensm_mode", "ensm_mode_available",
ensm_mode_available, NULL);
iio_combo_box_init(&glb_widgets[num_glb++],
dev, NULL, "calib_mode", "calib_mode_available",
calib_mode_available, NULL);
iio_combo_box_init(&glb_widgets[num_glb++],
dev, NULL, "trx_rate_governor", "trx_rate_governor_available",
trx_rate_governor_available, NULL);
dcxo_coarse_num = num_glb;
iio_spin_button_int_init_from_builder(&glb_widgets[num_glb++],
dev, NULL, "dcxo_tune_coarse", builder, "dcxo_coarse_tune",
0);
dcxo_fine_num = num_glb;
iio_spin_button_int_init_from_builder(&glb_widgets[num_glb++],
dev, NULL, "dcxo_tune_fine", builder, "dcxo_fine_tune",
0);
rx_widgets = &glb_widgets[num_glb];
/* Receive Chain */
iio_combo_box_init(&rx_widgets[num_rx++],
dev, ch0, "gain_control_mode",
"gain_control_mode_available",
rx_gain_control_modes_rx1, NULL);
iio_combo_box_init(&rx_widgets[num_rx++],
dev, ch0, "rf_port_select",
"rf_port_select_available",
rf_port_select_rx, NULL);
if (is_2rx_2tx)
iio_combo_box_init(&rx_widgets[num_rx++],
dev, ch1, "gain_control_mode",
"gain_control_mode_available",
rx_gain_control_modes_rx2, NULL);
rx1_gain = num_rx;
iio_spin_button_int_init_from_builder(&rx_widgets[num_rx++],
dev, ch0, "hardwaregain", builder,
"hardware_gain_rx1", NULL);
if (is_2rx_2tx) {
rx2_gain = num_rx;
iio_spin_button_int_init_from_builder(&rx_widgets[num_rx++],
dev, ch1, "hardwaregain", builder,
"hardware_gain_rx2", NULL);
}
rx_sample_freq = num_rx;
iio_spin_button_int_init_from_builder(&rx_widgets[num_rx++],
dev, ch0, "sampling_frequency", builder,
"sampling_freq_rx", &mhz_scale);
iio_spin_button_add_progress(&rx_widgets[num_rx - 1]);
iio_spin_button_int_init_from_builder(&rx_widgets[num_rx++],
dev, ch0, "rf_bandwidth", builder, "rf_bandwidth_rx",
&mhz_scale);
iio_spin_button_add_progress(&rx_widgets[num_rx - 1]);
rx_lo = num_rx;
ch1 = iio_device_find_channel(dev, "altvoltage0", true);
if (iio_channel_find_attr(ch1, "frequency"))
freq_name = "frequency";
else
freq_name = "RX_LO_frequency";
iio_spin_button_s64_init_from_builder(&rx_widgets[num_rx++],
dev, ch1, freq_name, builder,
"rx_lo_freq", &mhz_scale);
iio_spin_button_add_progress(&rx_widgets[num_rx - 1]);
iio_toggle_button_init_from_builder(&rx_widgets[num_rx++],
dev, ch0, "quadrature_tracking_en", builder,
"quad", 0);
iio_toggle_button_init_from_builder(&rx_widgets[num_rx++],
dev, ch0, "rf_dc_offset_tracking_en", builder,
"rfdc", 0);
iio_toggle_button_init_from_builder(&rx_widgets[num_rx++],
dev, ch0, "bb_dc_offset_tracking_en", builder,
"bbdc", 0);
iio_spin_button_init_from_builder(&rx_widgets[num_rx],
dev, ch1, "calibphase",
builder, "rx1_phase_rotation", NULL);
iio_spin_button_add_progress(&rx_widgets[num_rx++]);
ch0 = iio_device_find_channel(dev, "altvoltage0", true);
if (iio_channel_find_attr(ch0, "fastlock_store"))
rx_fastlock_store_name = "fastlock_store";
else
rx_fastlock_store_name = "RX_LO_fastlock_store";
if (iio_channel_find_attr(ch0, "fastlock_recall"))
rx_fastlock_recall_name = "fastlock_recall";
else
rx_fastlock_recall_name = "RX_LO_fastlock_recall";
/* Transmit Chain */
tx_widgets = &rx_widgets[num_rx];
ch0 = iio_device_find_channel(dev, "voltage0", true);
if (is_2rx_2tx)
ch1 = iio_device_find_channel(dev, "voltage1", true);
tx_rssi_available = ch0 && iio_channel_find_attr(ch0, "rssi");
if (is_2rx_2tx)
tx_rssi_available = tx_rssi_available &&
(ch1 && iio_channel_find_attr(ch1, "rssi"));
iio_combo_box_init(&tx_widgets[num_tx++],
dev, ch0, "rf_port_select",
"rf_port_select_available",
rf_port_select_tx, NULL);
iio_spin_button_init_from_builder(&tx_widgets[num_tx++],
dev, ch0, "hardwaregain", builder,
"hardware_gain_tx1", &inv_scale);
if (is_2rx_2tx)
iio_spin_button_init_from_builder(&tx_widgets[num_tx++],
dev, ch1, "hardwaregain", builder,
"hardware_gain_tx2", &inv_scale);
tx_sample_freq = num_tx;
iio_spin_button_int_init_from_builder(&tx_widgets[num_tx++],
dev, ch0, "sampling_frequency", builder,
"sampling_freq_tx", &mhz_scale);
iio_spin_button_add_progress(&tx_widgets[num_tx - 1]);
iio_spin_button_int_init_from_builder(&tx_widgets[num_tx++],
dev, ch0, "rf_bandwidth", builder,
"rf_bandwidth_tx", &mhz_scale);
iio_spin_button_add_progress(&tx_widgets[num_tx - 1]);
tx_lo = num_tx;
ch1 = iio_device_find_channel(dev, "altvoltage1", true);
if (iio_channel_find_attr(ch1, "frequency"))
freq_name = "frequency";
else
freq_name = "TX_LO_frequency";
iio_spin_button_s64_init_from_builder(&tx_widgets[num_tx++],
dev, ch1, freq_name, builder, "tx_lo_freq", &mhz_scale);
iio_spin_button_add_progress(&tx_widgets[num_tx - 1]);
ch1 = iio_device_find_channel(dev, "altvoltage1", true);
if (ini_fn)
load_profile(ini_fn);
/* Update all widgets with current values */
printf("Updating widgets...\n");
update_widgets();
rx_freq_info_update();
printf("Updating FIR filter...\n");
filter_fir_update();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(disable_all_fir_filters), true);
glb_settings_update_labels();
rssi_update_labels();
dac_data_manager_freq_widgets_range_update(dac_tx_manager,
get_gui_tx_sampling_freq() / 2.0);
dac_data_manager_update_iio_widgets(dac_tx_manager);
/* Widgets bindings */
g_builder_bind_property(builder, "rssi_tx1", "visible",
"label_rssi_tx1", "sensitive", G_BINDING_DEFAULT);
g_builder_bind_property(builder, "rssi_tx2", "visible",
"label_rssi_tx2", "sensitive", G_BINDING_DEFAULT);
/* Connect signals */
if (iio_channel_find_attr(ch1, "fastlock_store"))
tx_fastlock_store_name = "fastlock_store";
else
tx_fastlock_store_name = "TX_LO_fastlock_store";
if (iio_channel_find_attr(ch1, "fastlock_recall"))
tx_fastlock_recall_name = "fastlock_recall";
else
tx_fastlock_recall_name = "TX_LO_fastlock_recall";
g_builder_connect_signal(builder, "rx1_phase_rotation", "value-changed",
G_CALLBACK(rx_phase_rotation_set), (gpointer *)0);
g_builder_connect_signal(builder, "rx2_phase_rotation", "value-changed",
G_CALLBACK(rx_phase_rotation_set), (gpointer *)2);
g_builder_connect_signal(builder, "sampling_freq_tx", "value-changed",
G_CALLBACK(tx_sample_rate_changed), NULL);
g_builder_connect_signal(builder, "fmcomms2_settings_reload", "clicked",
G_CALLBACK(reload_button_clicked), NULL);
g_builder_connect_signal(builder, "filter_fir_config", "file-set",
G_CALLBACK(filter_fir_config_file_set_cb), NULL);
g_builder_connect_signal(builder, "rx_fastlock_store", "clicked",
G_CALLBACK(fastlock_clicked), (gpointer) 1);
g_builder_connect_signal(builder, "tx_fastlock_store", "clicked",
G_CALLBACK(fastlock_clicked), (gpointer) 2);
g_builder_connect_signal(builder, "rx_fastlock_recall", "clicked",
G_CALLBACK(fastlock_clicked), (gpointer) 3);
g_builder_connect_signal(builder, "tx_fastlock_recall", "clicked",
G_CALLBACK(fastlock_clicked), (gpointer) 4);
g_signal_connect_after(section_toggle[SECTION_GLOBAL], "clicked",
G_CALLBACK(hide_section_cb), section_setting[SECTION_GLOBAL]);
g_signal_connect_after(section_toggle[SECTION_TX], "clicked",
G_CALLBACK(hide_section_cb), section_setting[SECTION_TX]);
g_signal_connect_after(section_toggle[SECTION_RX], "clicked",
G_CALLBACK(hide_section_cb), section_setting[SECTION_RX]);
g_signal_connect_after(section_toggle[SECTION_FPGA], "clicked",
G_CALLBACK(hide_section_cb), section_setting[SECTION_FPGA]);
g_signal_connect_after(ensm_mode_available, "changed",
G_CALLBACK(glb_settings_update_labels), NULL);
g_signal_connect_after(calib_mode_available, "changed",
G_CALLBACK(glb_settings_update_labels), NULL);
g_signal_connect_after(trx_rate_governor_available, "changed",
G_CALLBACK(glb_settings_update_labels), NULL);
g_signal_connect_after(rx_gain_control_modes_rx1, "changed",
G_CALLBACK(glb_settings_update_labels), NULL);
g_signal_connect_after(rx_gain_control_modes_rx2, "changed",
G_CALLBACK(glb_settings_update_labels), NULL);
if (tx_rssi_available)
g_signal_connect(rf_port_select_rx, "changed",
G_CALLBACK(rf_port_select_rx_changed_cb), NULL);
g_signal_connect_after(enable_fir_filter_rx, "toggled",
G_CALLBACK(filter_fir_enable), NULL);
g_signal_connect_after(fir_filter_en_tx, "toggled",
G_CALLBACK(filter_fir_enable), NULL);
g_signal_connect_after(enable_fir_filter_rx_tx, "toggled",
G_CALLBACK(filter_fir_enable), NULL);
g_signal_connect_after(disable_all_fir_filters, "toggled",
G_CALLBACK(filter_fir_enable), NULL);
g_signal_connect(up_down_converter, "toggled",
G_CALLBACK(up_down_converter_toggled_cb), NULL);
make_widget_update_signal_based(glb_widgets, num_glb);
make_widget_update_signal_based(rx_widgets, num_rx);
make_widget_update_signal_based(tx_widgets, num_tx);
iio_spin_button_set_on_complete_function(&rx_widgets[rx_sample_freq],
sample_frequency_changed_cb, NULL);
iio_spin_button_set_on_complete_function(&tx_widgets[tx_sample_freq],
sample_frequency_changed_cb, NULL);
iio_spin_button_set_on_complete_function(&rx_widgets[rx_lo],
sample_frequency_changed_cb, NULL);
iio_spin_button_set_on_complete_function(&tx_widgets[tx_lo],
sample_frequency_changed_cb, NULL);
add_ch_setup_check_fct("cf-ad9361-lpc", channel_combination_check);
struct iio_device *adc_dev;
struct extra_dev_info *adc_info;
adc_dev = iio_context_find_device(get_context_from_osc(), CAP_DEVICE);
if (adc_dev) {
adc_info = iio_device_get_data(adc_dev);
if (adc_info)
adc_info->plugin_fft_corr = 20 * log10(1/sqrt(HANNING_ENBW));
}
block_diagram_init(builder, 2, "fmcomms2.svg", "AD_FMCOMM2S2_RevC.jpg");
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(filter_fir_config), OSC_FILTER_FILE_PATH);
dac_data_manager_set_buffer_chooser_current_folder(dac_tx_manager, OSC_WAVEFORM_FILE_PATH);
if (!is_2rx_2tx) {
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "frame_rx2")));
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "frame_fpga_rx2")));
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "table_hw_gain_tx2")));
}
if (!tx_rssi_available) {
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "rssi_tx1")));
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "rssi_tx2")));
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "label_rssi_tx1")));
gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(builder, "label_rssi_tx2")));
}
gtk_widget_set_visible(up_down_converter, has_udc_driver);
g_timeout_add(1000, (GSourceFunc) update_display, ctx);
can_update_widgets = true;
return fmcomms2_panel;
}
void introduce_dialog::contact_2_selected(int)
{
update_widgets();
}
void se_expr_param_t::expr_editor_apply( const std::string& new_expr)
{
set_value( new_expr);
param_set()->notify_parent();
update_widgets();
}
void generic_sys_coordinator::on_system_update()
{
if(m_request_termination)
{
return;
}
time_check();
bool result;
{
std::lock_guard< std::mutex > guard(m_sys_mutex);
result = m_sys->update(nullptr);
m_system_st = result ? SystemState::Active : SystemState::Completed;
}
++m_step;
m_ready_to_display = true;
auto uinf = m_sys->get_update_info();
if(uinf.type == rtp::i_system::update_info::Type::Realtime)
{
if(m_system_st == SystemState::Completed || (m_step % RenderPeriod == 0))
{
update_widgets();
}
if(m_system_st == SystemState::Active)
{
m_timer.expires_at(m_timer.expires_at() + boost::posix_time::milliseconds(1000.0f / uinf.frequency));
m_timer.async_wait(boost::bind(&generic_sys_coordinator::on_system_update, this));
}
else if(m_finish_cb)
{
m_finish_cb();
}
}
else
{
if(m_widget->get_drawer()->is_animated())
{
auto anim_drawer = static_cast<rtp::animated_system_drawer*>(m_widget->get_drawer());
anim_drawer->start();
// Initiate animation sequence
m_timer.expires_at(m_timer.expires_at() + boost::posix_time::milliseconds(1000.0f / AnimationFreq));
m_timer.async_wait(boost::bind(&generic_sys_coordinator::on_animation_update, this));
}
else if(m_system_st == SystemState::Active)
{
m_timer.expires_at(m_timer.expires_at() + boost::posix_time::milliseconds(1000.0f / NonRealtimeFreq));
m_timer.async_wait(boost::bind(&generic_sys_coordinator::on_system_update, this));
}
else if(m_finish_cb)
{
m_finish_cb();
}
// Draw
update_widgets();
}
}
static void reload_button_clicked(GtkButton *btn, gpointer data)
{
update_widgets();
dac_data_manager_update_iio_widgets(dac_tx_manager);
}
