NetlistEditor *
netlist_editor_new_from_schematic_view (SchematicView *sv)
{
NetlistEditor *editor;
gchar *name = "/tmp/oregano.netlist";
GError *error = 0;
Schematic *sm;
OreganoEngine *engine;
sm = schematic_view_get_schematic (sv);
engine = oregano_engine_factory_create_engine (oregano.engine, sm);
oregano_engine_generate_netlist (engine, name, &error);
g_object_unref (engine);
if (error != NULL) {
if (g_error_matches (error, OREGANO_ERROR, OREGANO_SIMULATE_ERROR_NO_CLAMP) ||
g_error_matches (error, OREGANO_ERROR, OREGANO_SIMULATE_ERROR_NO_GND) ||
g_error_matches (error, OREGANO_ERROR, OREGANO_SIMULATE_ERROR_IO_ERROR)) {
oregano_error_with_title (_("Could not create a netlist"), error->message);
g_clear_error (&error);
}
else {
oregano_error (_("An unexpected error has occurred"));
}
return NULL;
}
editor = netlist_editor_new_from_file (name);
if (editor) {
editor->priv->sv = sv;
}
return editor;
}
void simulation_show (GtkWidget *widget, SchematicView *sv)
{
GtkWidget *w;
GtkBuilder *gui;
GError *e = NULL;
Simulation *s;
Schematic *sm;
g_return_if_fail (sv != NULL);
sm = schematic_view_get_schematic (sv);
s = schematic_get_simulation (sm);
if ((gui = gtk_builder_new ()) == NULL) {
log_append (s->logstore, _ ("Simulation"),
_ ("Could not create simulation dialog - Builder creation failed."));
return;
}
gtk_builder_set_translation_domain (gui, NULL);
// Only allow one instance of the dialog box per schematic.
if (s->dialog) {
gdk_window_raise (gtk_widget_get_window (GTK_WIDGET (s->dialog)));
return;
}
if (gtk_builder_add_from_file (gui, OREGANO_UIDIR "/simulation.ui", &e) <= 0) {
log_append_error (s->logstore, _ ("Simulation"), _ ("Could not create simulation dialog"),
e);
g_clear_error (&e);
return;
}
w = GTK_WIDGET (gtk_builder_get_object (gui, "toplevel"));
if (!w) {
log_append (s->logstore, _ ("Simulation"),
_ ("Could not create simulation dialog - .ui file lacks widget "
"called \"toplevel\"."));
return;
}
s->dialog = GTK_DIALOG (w);
g_signal_connect (G_OBJECT (w), "delete_event", G_CALLBACK (delete_event_cb), s);
w = GTK_WIDGET (gtk_builder_get_object (gui, "progressbar"));
s->progress = GTK_PROGRESS_BAR (w);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (s->progress), 0.0);
w = GTK_WIDGET (gtk_builder_get_object (gui, "progress_label"));
s->progress_label = GTK_LABEL (w);
g_signal_connect (G_OBJECT (s->dialog), "response", G_CALLBACK (cancel_cb), s);
gtk_widget_show_all (GTK_WIDGET (s->dialog));
s->sv = sv;
simulate_cmd (s);
}
void
simulation_show (GtkWidget *widget, SchematicView *sv)
{
GtkWidget *w;
GladeXML *gui;
Simulation *s;
Schematic *sm;
g_return_if_fail (sv != NULL);
sm = schematic_view_get_schematic (sv);
s = schematic_get_simulation (sm);
/* Only allow one instance of the dialog box per schematic. */
if (s->dialog){
gdk_window_raise (GTK_WIDGET (s->dialog)->window);
return;
}
if (!g_file_test (OREGANO_GLADEDIR "/simulation.glade2",
G_FILE_TEST_EXISTS)) {
oregano_error (_("Could not create simulation dialog"));
return;
}
gui = glade_xml_new (OREGANO_GLADEDIR "/simulation.glade2", "toplevel", NULL);
if (!gui) {
oregano_error (_("Could not create simulation dialog"));
return;
}
w = glade_xml_get_widget (gui, "toplevel");
if (!w) {
oregano_error (_("Could not create simulation dialog"));
return;
}
s->dialog = GTK_DIALOG (w);
g_signal_connect (G_OBJECT (w), "delete_event", G_CALLBACK (delete_event_cb), s);
w = glade_xml_get_widget (gui, "progressbar");
s->progress = GTK_PROGRESS_BAR (w);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (s->progress), 0.0);
w = glade_xml_get_widget (gui, "progress_label");
s->progress_label = GTK_LABEL (w);
g_signal_connect (G_OBJECT (s->dialog), "response", G_CALLBACK (cancel_cb), s);
gtk_widget_show_all (GTK_WIDGET (s->dialog));
s->sv = sv;
simulate_cmd (s);
}
void
netlist_editor_simulate (GtkWidget * widget, NetlistEditor * nle)
{
Schematic *sm;
gchar *name;
GtkTextView *tview;
GtkTextBuffer *buffer;
GtkTextIter start, end;
FILE *fp;
GError *error = 0;
OreganoEngine *engine;
// FIXME: OreganoEngine now override the netlist when start!
return;
tview = nle->priv->view;
buffer = gtk_text_view_get_buffer (tview);
gtk_text_buffer_get_start_iter (buffer, &start);
gtk_text_buffer_get_end_iter (buffer, &end);
sm = schematic_view_get_schematic (nle->priv->sv);
//name = nl_generate (sm, NULL, &error);
if (error != NULL) {
if (g_error_matches (error, OREGANO_ERROR, OREGANO_SIMULATE_ERROR_NO_CLAMP) ||
g_error_matches (error, OREGANO_ERROR, OREGANO_SIMULATE_ERROR_NO_GND) ||
g_error_matches (error, OREGANO_ERROR, OREGANO_SIMULATE_ERROR_IO_ERROR)) {
oregano_error_with_title (_("Could not create a netlist"), error->message);
g_clear_error (&error);
} else {
oregano_error (
_("An unexpected error has occurred"));
}
return;
}
/* Save TextBuffer to 'name' */
fp = fopen (name, "wt");
if (!fp) {
gchar *msg;
msg = g_strdup_printf (_("The file %s could not be saved"), name);
oregano_error_with_title (_("Could not save temporary netlist file"), msg);
g_free (msg);
return;
}
fputs (gtk_text_buffer_get_text (buffer, &start, &end, FALSE), fp);
fclose (fp);
schematic_set_netlist_filename (sm, name);
simulation_show (NULL, nle->priv->sv);
g_free (name);
}
static void
mouse_over_wire_cb (WireItem *item, SchematicView *sv)
{
GList *wires;
Wire *wire;
NodeStore *store;
Sheet *sheet;
sheet = schematic_view_get_sheet (sv);
if (sheet->state != SHEET_STATE_NONE)
return;
store = schematic_get_store (schematic_view_get_schematic (sv));
node_store_node_foreach (store, (GHFunc *) node_foreach_reset, NULL);
for (wires = store->wires; wires; wires = wires->next) {
wire = wires->data;
wire_set_visited (wire, FALSE);
}
wire = WIRE (sheet_item_get_data (SHEET_ITEM (item)));
wire_traverse (wire);
}
void
settings_show (GtkWidget *widget, SchematicView *sv)
{
gint i;
GtkWidget *engine_group = NULL;
GtkWidget *w, *pbox, *toplevel;
GtkBuilder *gui;
GError *perror = NULL;
gchar *msg;
Settings *s;
Schematic *sm;
g_return_if_fail (sv != NULL);
// If no engine available, stop oregano
if ((g_find_program_in_path (engine[0]) == NULL) &&
(g_find_program_in_path (engine[1]) == NULL)) {
gchar *msg;
msg = g_strdup_printf (
_("No engine allowing analysis is available.\n"
"You might install one, at least! \n"
"Either ngspice or gnucap."));
oregano_error_with_title (_("Could not create settings dialog"), msg);
g_free (msg);
return;
}
g_return_if_fail (sv != NULL);
if ((gui = gtk_builder_new ()) == NULL) {
oregano_error (_("Could not create settings dialog"));
return;
}
gtk_builder_set_translation_domain (gui, NULL);
sm = schematic_view_get_schematic (sv);
s = schematic_get_settings (sm);
// Only allow one instance of the property box per schematic.
if (GTK_WIDGET (SETTINGS (s)->pbox)) {
gdk_window_raise (gtk_widget_get_window (
GTK_WIDGET (SETTINGS (s)->pbox)));
return;
}
if (gtk_builder_add_from_file (gui, OREGANO_UIDIR "/settings.ui", &perror) <= 0) {
msg = perror->message;
oregano_error_with_title (_("Could not create settings dialog"), msg);
g_error_free (perror);
return;
}
w = toplevel = GTK_WIDGET (gtk_builder_get_object (gui, "toplevel"));
if (!w) {
oregano_error (_("Could not create settings dialog"));
return;
}
g_signal_connect (G_OBJECT (w), "delete_event",
G_CALLBACK (delete_event_callback), s);
pbox = toplevel;
s->pbox = GTK_WIDGET (pbox);
w = GTK_WIDGET (gtk_builder_get_object (gui, "close_bt"));
g_signal_connect (G_OBJECT (w), "clicked",
G_CALLBACK (apply_callback), s);
w = GTK_WIDGET (gtk_builder_get_object (gui, "splash-enable"));
s->w_show_splash = w;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), oregano.show_splash);
w = GTK_WIDGET (gtk_builder_get_object (gui, "compress-enable"));
s->w_compress_files = w;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w),
oregano.compress_files);
w = GTK_WIDGET (gtk_builder_get_object (gui, "log-enable"));
s->w_show_log = w;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), oregano.show_log);
w = GTK_WIDGET (gtk_builder_get_object (gui, "grid-size"));
gtk_widget_set_sensitive (w, FALSE);
w = GTK_WIDGET (gtk_builder_get_object (gui, "realtime-enable"));
gtk_widget_set_sensitive (w, FALSE);
w = GTK_WIDGET (gtk_builder_get_object (gui, "engine_table"));
for (i = 0; i < OREGANO_ENGINE_COUNT; i++) {
if (engine_group)
button[i] = gtk_radio_button_new_with_label_from_widget (
GTK_RADIO_BUTTON (engine_group), engine[i]);
else
button[i] = engine_group =
gtk_radio_button_new_with_label_from_widget (NULL, engine[i]);
g_object_set_data (G_OBJECT (button[i]), "id", GUINT_TO_POINTER (i));
gtk_grid_attach (GTK_GRID (w), button[i], 0, i, 1, 1);
g_signal_connect (G_OBJECT (button[i]), "clicked",
G_CALLBACK (set_engine_name), s);
}
// Is the engine available?
// In that case the button is active
if (g_find_program_in_path (engine[oregano.engine]) != NULL)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button[oregano.engine]),
TRUE);
// Otherwise the button is inactive
else
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button[oregano.engine]),
FALSE);
// If no engine available, stop oregano
if ((g_find_program_in_path (engine[0]) == NULL) &&
(g_find_program_in_path (engine[1]) == NULL)) {
gchar *msg;
msg = g_strdup_printf (
_("No engine allowing analysis is available.\n"
"You might install one, at least! \n"
"Either ngspice or gnucap."));
oregano_error_with_title (_("Could not create settings dialog"), msg);
g_free (msg);
}
gtk_widget_show_all (toplevel);
}
/**
* FIXME this code is an ugly piece of shit, fix it!
*/
void sim_settings_show (GtkWidget *widget, SchematicView *sv)
{
int i;
gboolean found;
gint rc, active, index;
GtkWidget *toplevel, *w, *w1, *pbox, *combo_box;
GtkTreeView *opt_list;
GtkCellRenderer *cell_option, *cell_value;
GtkTreeViewColumn *column_option, *column_value;
GtkListStore *opt_model;
GtkTreeIter treeiter;
GtkBuilder *builder;
GError *e = NULL;
SimSettings *s;
GList *iter;
GList *voltmeters = NULL;
GList *voltmeters_with_type = NULL;
GList *sources = NULL;
GList *sources_ac = NULL;
GtkComboBox *node_box;
GtkListStore *node_list_store;
gchar *text, *text2;
gchar **node_ids;
GSList *slist = NULL;
g_return_if_fail (sv != NULL);
Schematic *sm = schematic_view_get_schematic (sv);
SimSettingsGui *s_gui = schematic_get_sim_settings_gui (sm);
s = s_gui->sim_settings;
// Only allow one instance of the property box per schematic.
if (s_gui->pbox != NULL) {
if (gtk_widget_get_visible (s_gui->pbox) == FALSE) {
gtk_widget_set_visible (s_gui->pbox, TRUE);
}
GdkWindow *window = gtk_widget_get_window (s_gui->pbox);
g_assert (window != NULL);
gdk_window_raise (window);
return;
}
if ((builder = gtk_builder_new ()) == NULL) {
log_append (schematic_get_log_store (sm), _ ("SimulationSettings"),
_ ("Could not create simulation settings dialog"));
return;
}
gtk_builder_set_translation_domain (builder, NULL);
gtk_builder_add_from_file (builder, OREGANO_UIDIR "/sim-settings.ui", &e);
if (e) {
log_append_error (schematic_get_log_store (sm), _ ("SimulationSettings"),
_ ("Could not create simulation settings dialog due to "
"missing " OREGANO_UIDIR "/sim-settings.ui file"),
e);
g_clear_error (&e);
return;
}
toplevel = GTK_WIDGET (gtk_builder_get_object (builder, "toplevel"));
if (toplevel == NULL) {
log_append (schematic_get_log_store (sm), _ ("SimulationSettings"),
_ ("Could not create simulation settings dialog due to missing "
"\"toplevel\" widget in " OREGANO_UIDIR "/sim-settings.ui file"));
return;
}
pbox = toplevel;
s_gui->pbox = pbox;
s_gui->notebook = GTK_NOTEBOOK (gtk_builder_get_object (builder, "notebook"));
g_signal_connect (G_OBJECT (pbox), "delete_event", G_CALLBACK (delete_event_cb), s_gui);
// Prepare options list
s_gui->w_opt_value = GTK_ENTRY (gtk_builder_get_object (builder, "opt_value"));
opt_list = GTK_TREE_VIEW (gtk_builder_get_object (builder, "option_list"));
s_gui->w_opt_list = opt_list;
// Grab the frames
s_gui->w_trans_frame = GTK_WIDGET (gtk_builder_get_object (builder, "trans_frame"));
s_gui->w_ac_frame = GTK_WIDGET (gtk_builder_get_object (builder, "ac_frame"));
s_gui->w_dcsweep_frame = GTK_WIDGET (gtk_builder_get_object (builder, "dcsweep_frame"));
s_gui->w_fourier_frame = GTK_WIDGET (gtk_builder_get_object (builder, "fourier_frame"));
s_gui->w_noise_frame = GTK_WIDGET (gtk_builder_get_object (builder, "noise_frame"));
// Create the Columns
cell_option = gtk_cell_renderer_text_new ();
cell_value = gtk_cell_renderer_text_new ();
column_option =
gtk_tree_view_column_new_with_attributes (N_ ("Option"), cell_option, "text", 0, NULL);
column_value =
gtk_tree_view_column_new_with_attributes (N_ ("Value"), cell_value, "text", 1, NULL);
// Create the model
opt_model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model (opt_list, GTK_TREE_MODEL (opt_model));
gtk_tree_view_append_column (opt_list, column_option);
gtk_tree_view_append_column (opt_list, column_value);
if (s->options == NULL) {
// Load defaults
for (i = 0; default_options[i].name; i++) {
gtk_list_store_append (opt_model, &treeiter);
gtk_list_store_set (opt_model, &treeiter, 0, default_options[i].name, -1);
}
} else {
// Load schematic options
for (iter = s->options; iter; iter = iter->next) {
SimOption *so = iter->data;
if (so) {
gtk_list_store_append (opt_model, &treeiter);
gtk_list_store_set (opt_model, &treeiter, 0, so->name, -1);
}
}
}
// Set the options already stored
for (iter = s->options; iter; iter = iter->next) {
SimOption *so = iter->data;
if (so)
set_options_in_list (so->name, so->value, opt_list);
}
g_signal_connect (G_OBJECT (opt_list), "button_release_event", G_CALLBACK (select_opt_callback),
s);
w = GTK_WIDGET (gtk_builder_get_object (builder, "opt_accept"));
g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (option_setvalue), s_gui);
w = GTK_WIDGET (gtk_builder_get_object (builder, "opt_remove"));
w = GTK_WIDGET (gtk_builder_get_object (builder, "add_option"));
g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (option_remove), s_gui);
g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (add_option), s_gui);
// Creation of Close Button
w = GTK_WIDGET (gtk_builder_get_object (builder, "button1"));
g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (response_callback), sv);
// Get the list of voltmeters (normal mode)
rc = get_voltmeters_list(&voltmeters, sm, e, FALSE);
if (rc) {
sim_settings_set_dc(s, FALSE);
sim_settings_set_fourier(s, FALSE);
}
// Get the list of voltmeters (AC mode, i.e. with measurement type)
rc = get_voltmeters_list(&voltmeters_with_type, sm, e, TRUE);
if (rc) {
sim_settings_set_ac(s, FALSE);
}
// Get the list of sources (all types)
rc = get_voltage_sources_list(&sources, sm, e, FALSE);
if (rc) {
sim_settings_set_dc(s, FALSE);
}
// Get the list of AC sources
rc = get_voltage_sources_list(&sources_ac, sm, e, TRUE);
if (rc) {
sim_settings_set_noise(s, FALSE);
}
// Transient //
// ********* //
w = GTK_WIDGET (gtk_builder_get_object (builder, "trans_start"));
s_gui->w_trans_start = w;
if (s->trans_start)
gtk_entry_set_text (GTK_ENTRY (w), s->trans_start);
g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (entry_changed_cb), s_gui);
w = GTK_WIDGET (gtk_builder_get_object (builder, "trans_stop"));
s_gui->w_trans_stop = w;
if (s->trans_stop)
gtk_entry_set_text (GTK_ENTRY (w), s->trans_stop);
g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (entry_changed_cb), s_gui);
w = GTK_WIDGET (gtk_builder_get_object (builder, "trans_step"));
s_gui->w_trans_step = w;
if (s->trans_step)
gtk_entry_set_text (GTK_ENTRY (w), s->trans_step);
g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (entry_changed_cb), s_gui);
w = GTK_WIDGET (gtk_builder_get_object (builder, "trans_enable"));
s_gui->w_trans_enable = w;
g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (trans_enable_cb), s_gui);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), s->trans_enable);
w = GTK_WIDGET (gtk_builder_get_object (builder, "trans_step_enable"));
s_gui->w_trans_step_enable = w;
g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (trans_step_enable_cb), s_gui);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), s->trans_step_enable);
// get the gui element
w = GTK_WIDGET (gtk_builder_get_object (builder, "trans_init_cond"));
// save the gui element to struct
s_gui->w_trans_init_cond = w;
// Set checkbox enabled, if trans_init_cond equal true.
// trans_init_cond could be set to true because
// - user opened the settings dialog some seconds ago and has set the checkbox
// - user opened old file in which there was set the checkbox state to true
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), s->trans_init_cond);
// get the gui element
w = GTK_WIDGET (gtk_builder_get_object (builder, "trans_analyze_all"));
// save the gui element to struct
s_gui->w_trans_analyze_all = w;
// Set checkbox enabled, if trans_analyze_all equal true.
// trans_init_cond could be set to true because
// - user opened the settings dialog some seconds ago and has set the checkbox
// - user opened old file in which there was set the checkbox state to true
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), s->trans_analyze_all);
// AC //
// *** //
w = GTK_WIDGET (gtk_builder_get_object (builder, "ac_enable"));
s_gui->w_ac_enable = w;
g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (ac_enable_cb), s_gui);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), s->ac_enable);
w1 = GTK_WIDGET (gtk_builder_get_object (builder, "grid14"));
// FIXME: Should enable more than just one output as in the Fourier analysis
w = GTK_WIDGET (gtk_builder_get_object (builder, "ac_vout"));
gtk_widget_destroy (w); // FIXME wtf??
combo_box = gtk_combo_box_text_new ();
gtk_grid_attach (GTK_GRID (w1), combo_box, 1, 0, 1, 1);
s_gui->w_ac_vout = combo_box;
if (voltmeters_with_type) {
index = 0;
active = 0;
for (iter = voltmeters_with_type; iter; iter = iter->next) {
if (g_strcmp0 (iter->data, "VM(0)"))
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), iter->data);
if (!g_strcmp0(s->ac_vout, iter->data))
active = index;
index++;
}
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), active);
}
g_signal_connect (G_OBJECT (combo_box), "changed", G_CALLBACK (entry_changed_cb), s);
// Initialisation of the various scale types
w = GTK_WIDGET (gtk_builder_get_object (builder, "ac_type"));
gtk_widget_destroy (w); // FIXME wtf??
combo_box = gtk_combo_box_text_new ();
gtk_grid_attach (GTK_GRID (w1), combo_box, 1, 1, 1, 1);
s_gui->w_ac_type = combo_box;
{
index = 0;
active = 0;
for (; scale_types_list[index] != NULL; index++) {
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), scale_types_list[index]);
if (!g_strcmp0(s->ac_type, scale_types_list[index]))
active = index;
}
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), active);
}
g_assert (GTK_IS_COMBO_BOX (combo_box));
g_signal_connect (G_OBJECT (combo_box), "changed", G_CALLBACK (entry_changed_cb), s_gui);
w = GTK_WIDGET (gtk_builder_get_object (builder, "ac_npoints"));
s_gui->w_ac_npoints = w;
gtk_entry_set_text (GTK_ENTRY (w), s->ac_npoints);
g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (entry_changed_cb), s_gui);
w = GTK_WIDGET (gtk_builder_get_object (builder, "ac_start"));
s_gui->w_ac_start = w;
gtk_entry_set_text (GTK_ENTRY (w), s->ac_start);
g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (entry_changed_cb), s_gui);
w = GTK_WIDGET (gtk_builder_get_object (builder, "ac_stop"));
s_gui->w_ac_stop = w;
gtk_entry_set_text (GTK_ENTRY (w), s->ac_stop);
g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (entry_changed_cb), s_gui);
// DC //
// ***** //
w = GTK_WIDGET (gtk_builder_get_object (builder, "dc_enable"));
s_gui->w_dc_enable = w;
g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (dc_enable_cb), s_gui);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), s->dc_enable);
w1 = GTK_WIDGET (gtk_builder_get_object (builder, "grid13"));
w = GTK_WIDGET (gtk_builder_get_object (builder, "dc_vin"));
gtk_widget_destroy (w); // FIXME wtf??
combo_box = gtk_combo_box_text_new ();
gtk_grid_attach (GTK_GRID (w1), combo_box, 1, 0, 1, 1);
s_gui->w_dc_vin = combo_box;
if (sources) {
index = 0;
active = 0;
for (iter = sources; iter; iter = iter->next) {
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), iter->data);
if (!g_strcmp0(s->dc_vin, iter->data))
active = index;
index++;
}
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), active);
}
g_signal_connect (G_OBJECT (combo_box), "changed", G_CALLBACK (entry_changed_cb), s);
// FIXME: Should enable more than just one output as in the Fourier analysis
// FIXME: Should also allow to print currents through voltage sources
w = GTK_WIDGET (gtk_builder_get_object (builder, "dc_vout"));
gtk_widget_destroy (w); // FIXME wtf??
combo_box = gtk_combo_box_text_new ();
gtk_grid_attach (GTK_GRID (w1), combo_box, 1, 1, 1, 1);
s_gui->w_dc_vout = combo_box;
if (voltmeters) {
index = 0;
active = 0;
text = g_strdup_printf("V(%s)", s->dc_vout);
for (iter = voltmeters; iter; iter = iter->next) {
if (g_strcmp0 (iter->data, "V(0)"))
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), iter->data);
if (!g_strcmp0(text, iter->data))
active = index;
index++;
}
g_free (text);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), active);
}
g_signal_connect (G_OBJECT (combo_box), "changed", G_CALLBACK (entry_changed_cb), s_gui);
w = GTK_WIDGET (gtk_builder_get_object (builder, "dc_start"));
s_gui->w_dc_start = w;
gtk_entry_set_text (GTK_ENTRY (w), s->dc_start);
g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (entry_changed_cb), s_gui);
w = GTK_WIDGET (gtk_builder_get_object (builder, "dc_stop"));
s_gui->w_dc_stop = w;
gtk_entry_set_text (GTK_ENTRY (w), s->dc_stop);
g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (entry_changed_cb), s_gui);
w = GTK_WIDGET (gtk_builder_get_object (builder, "dc_step"));
s_gui->w_dc_step = w;
gtk_entry_set_text (GTK_ENTRY (w), s->dc_step);
g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (entry_changed_cb), s_gui);
// Fourier //
// ******* //
g_print ("XXXXXXXXXXXXXXXX\n");
w = GTK_WIDGET (gtk_builder_get_object (builder, "fourier_enable"));
s_gui->w_four_enable = w;
g_print ("XXXXXXXXXXXXXXXX %p %s\n", w, s->fourier_enable ? "TRUE" : "FALSE");
g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (fourier_enable_cb), s_gui);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), s->fourier_enable);
w = GTK_WIDGET (gtk_builder_get_object (builder, "fourier_freq"));
s_gui->w_four_freq = w;
g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (entry_changed_cb), s_gui);
gtk_entry_set_text (GTK_ENTRY (w), s->fourier_frequency);
w = GTK_WIDGET (gtk_builder_get_object (builder, "fourier_vout"));
s_gui->w_four_vout = w;
g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (entry_changed_cb), s_gui);
// Get rid of inexistent output vectors
text2 = NULL;
if (voltmeters) {
text = sim_settings_get_fourier_vout (s);
node_ids = g_strsplit (text, " ", 0);
g_free (text);
for (i = 0; node_ids[i] != NULL; i++) {
text = g_strdup_printf ("V(%s)", node_ids[i]);
found = FALSE;
for (iter = voltmeters; iter; iter = iter->next) {
if (!g_strcmp0 (text, iter->data))
found = TRUE;
}
g_free (text);
if (found) {
if (text2) {
text = text2;
text2 = g_strdup_printf ("%s %s", text2, node_ids[i]);
g_free (text);
} else {
text2 = g_strdup_printf ("%s", node_ids[i]);
}
}
}
if (!text2)
text2 = g_strdup ("");
sim_settings_set_fourier_vout (s, text2);
g_free (text2);
g_strfreev (node_ids);
}
text = NULL;
slist = g_slist_copy (s->fourier_vout);
if (slist) {
if (slist->data && atoi (slist->data) > 0)
text = g_strdup_printf ("V(%d)", atoi (slist->data));
slist = slist->next;
}
while (slist) {
if (slist->data && atoi (slist->data) > 0) {
if (text) {
text2 = text;
text = g_strdup_printf ("%s V(%d)", text, atoi (slist->data));
g_free (text2);
} else {
text = g_strdup_printf ("V(%d)", atoi (slist->data));
}
}
slist = slist->next;
}
if (text)
gtk_entry_set_text (GTK_ENTRY (w), text);
else
gtk_entry_set_text (GTK_ENTRY (w), "");
g_slist_free_full (slist, g_free);
// Present in the combo box the nodes of the schematic
w = GTK_WIDGET (gtk_builder_get_object (builder, "fourier_select_out"));
gtk_widget_destroy (w); // FIXME wtf???
w = GTK_WIDGET (gtk_builder_get_object (builder, "grid12"));
combo_box = gtk_combo_box_text_new ();
gtk_grid_attach (GTK_GRID (w), combo_box, 2, 2, 1, 1);
s_gui->w_four_combobox = combo_box;
node_box = GTK_COMBO_BOX (combo_box);
node_list_store = GTK_LIST_STORE (gtk_combo_box_get_model (node_box));
gtk_list_store_clear (node_list_store);
if (voltmeters) {
for (iter = voltmeters; iter; iter = iter->next) {
if (g_strcmp0 (iter->data, "V(0)"))
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (node_box), iter->data);
}
gtk_combo_box_set_active (GTK_COMBO_BOX (node_box), 0);
}
g_signal_connect (G_OBJECT (node_box), "changed", G_CALLBACK (entry_changed_cb), s);
w = GTK_WIDGET (gtk_builder_get_object (builder, "fourier_add"));
s_gui->w_four_add = w;
g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (fourier_add_vout_cb), s_gui);
w = GTK_WIDGET (gtk_builder_get_object (builder, "fourier_rem"));
s_gui->w_four_rem = w;
g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (fourier_remove_vout_cb), s_gui);
// Noise //
// *** //
w = GTK_WIDGET (gtk_builder_get_object (builder, "noise_enable"));
s_gui->w_noise_enable = w;
g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (noise_enable_cb), s_gui);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), s->noise_enable);
w1 = GTK_WIDGET (gtk_builder_get_object (builder, "grid1"));
w = GTK_WIDGET (gtk_builder_get_object (builder, "noise_vin"));
gtk_widget_destroy (w); // FIXME wtf??
combo_box = gtk_combo_box_text_new ();
gtk_grid_attach (GTK_GRID (w1), combo_box, 1, 0, 1, 1);
s_gui->w_noise_vin = combo_box;
if (sources_ac) {
index = 0;
active = 0;
for (iter = sources_ac; iter; iter = iter->next) {
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), iter->data);
if (!g_strcmp0(s->noise_vin, iter->data))
active = index;
index++;
}
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), active);
}
g_signal_connect (G_OBJECT (combo_box), "changed", G_CALLBACK (entry_changed_cb), s);
// FIXME: Should enable more than just one output as in the Fourier analysis
w = GTK_WIDGET (gtk_builder_get_object (builder, "noise_vout"));
gtk_widget_destroy (w); // FIXME wtf??
combo_box = gtk_combo_box_text_new ();
gtk_grid_attach (GTK_GRID (w1), combo_box, 1, 1, 1, 1);
s_gui->w_noise_vout = combo_box;
if (voltmeters) {
index = 0;
active = 0;
text = g_strdup_printf ("V(%s)", s->noise_vout);
for (iter = voltmeters; iter; iter = iter->next) {
if (g_strcmp0 (iter->data, "V(0)"))
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), iter->data);
if (!g_strcmp0(text, iter->data))
active = index;
index++;
}
g_free (text);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), active);
}
g_signal_connect (G_OBJECT (combo_box), "changed", G_CALLBACK (entry_changed_cb), s);
// Initialisation of the various scale types
w = GTK_WIDGET (gtk_builder_get_object (builder, "noise_type"));
gtk_widget_destroy (w); // FIXME wtf??
combo_box = gtk_combo_box_text_new ();
gtk_grid_attach (GTK_GRID (w1), combo_box, 1, 2, 1, 1);
s_gui->w_noise_type = combo_box;
{
index = 0;
active = 0;
for (; scale_types_list[index] != NULL; index++) {
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), scale_types_list[index]);
if (!g_strcmp0(s->noise_type, scale_types_list[index]))
active = index;
}
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), active);
}
g_assert (GTK_IS_COMBO_BOX (combo_box));
g_signal_connect (G_OBJECT (combo_box), "changed", G_CALLBACK (entry_changed_cb), s_gui);
w = GTK_WIDGET (gtk_builder_get_object (builder, "noise_npoints"));
s_gui->w_noise_npoints = w;
gtk_entry_set_text (GTK_ENTRY (w), s->noise_npoints);
g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (entry_changed_cb), s_gui);
w = GTK_WIDGET (gtk_builder_get_object (builder, "noise_start"));
s_gui->w_noise_start = w;
gtk_entry_set_text (GTK_ENTRY (w), s->noise_start);
g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (entry_changed_cb), s_gui);
w = GTK_WIDGET (gtk_builder_get_object (builder, "noise_stop"));
s_gui->w_noise_stop = w;
gtk_entry_set_text (GTK_ENTRY (w), s->noise_stop);
g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (entry_changed_cb), s_gui);
gtk_widget_show_all (toplevel);
trans_enable_cb (s_gui->w_trans_enable, s_gui);
trans_step_enable_cb (s_gui->w_trans_step_enable, s_gui);
ac_enable_cb (s_gui->w_ac_enable, s_gui);
dc_enable_cb (s_gui->w_dc_enable, s_gui);
fourier_enable_cb (s_gui->w_four_enable, s_gui);
noise_enable_cb (s_gui->w_noise_enable, s_gui);
g_list_free(sources);
g_list_free(voltmeters);
g_list_free(voltmeters_with_type);
}
static void response_callback (GtkButton *button, SchematicView *sv)
{
g_return_if_fail (sv != NULL);
g_return_if_fail (IS_SCHEMATIC_VIEW (sv));
g_return_if_fail (button != NULL);
g_return_if_fail (GTK_IS_BUTTON (button));
gint page;
gchar *tmp = NULL;
gchar **node_ids = NULL;
Schematic *sm = schematic_view_get_schematic (sv);
SimSettingsGui *s_gui = schematic_get_sim_settings_gui(sm);
SimSettings *s = s_gui->sim_settings;
g_object_get (s_gui->notebook, "page", &page, NULL);
// Transient analysis
s->trans_enable = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (s_gui->w_trans_enable));
g_free (s->trans_start);
s->trans_start = gtk_editable_get_chars (GTK_EDITABLE (s_gui->w_trans_start), 0, -1);
g_free (s->trans_stop);
s->trans_stop = gtk_editable_get_chars (GTK_EDITABLE (s_gui->w_trans_stop), 0, -1);
g_free (s->trans_step);
s->trans_step = gtk_editable_get_chars (GTK_EDITABLE (s_gui->w_trans_step), 0, -1);
s->trans_step_enable =
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (s_gui->w_trans_step_enable));
s->trans_init_cond =
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (s_gui->w_trans_init_cond));
s->trans_analyze_all =
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (s_gui->w_trans_analyze_all));
// DC
s->dc_enable = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (s_gui->w_dc_enable));
g_free (s->dc_vin);
s->dc_vin = NULL;
tmp = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (s_gui->w_dc_vin));
if (tmp) {
node_ids = g_strsplit (tmp, "V(", 0);
tmp = g_strdup (node_ids[1]);
g_strfreev (node_ids);
if (tmp) {
node_ids = g_strsplit (tmp, ")", 0);
g_free (tmp);
if (node_ids[0])
s->dc_vin = g_strdup (node_ids[0]);
else
s->dc_vin = g_strdup("");
g_strfreev (node_ids);
}
}
if (s->dc_vin == NULL)
s->dc_vin = g_strdup ("");
g_free (s->dc_vout);
s->dc_vout = NULL;
tmp = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (s_gui->w_dc_vout));
if (tmp) {
node_ids = g_strsplit (tmp, "V(", 0);
tmp = g_strdup (node_ids[1]);
g_strfreev (node_ids);
if (tmp) {
node_ids = g_strsplit (tmp, ")", 0);
g_free (tmp);
if (node_ids[0])
s->dc_vout = g_strdup (node_ids[0]);
else
s->dc_vout = g_strdup("");
g_strfreev (node_ids);
}
}
if (s->dc_vout == NULL)
s->dc_vout = g_strdup("");
g_free (s->dc_start);
s->dc_start = g_strdup (gtk_entry_get_text (GTK_ENTRY (s_gui->w_dc_start)));
g_free (s->dc_stop);
s->dc_stop = g_strdup (gtk_entry_get_text (GTK_ENTRY (s_gui->w_dc_stop)));
g_free (s->dc_step);
s->dc_step = g_strdup (gtk_entry_get_text (GTK_ENTRY (s_gui->w_dc_step)));
// AC
s->ac_enable = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (s_gui->w_ac_enable));
g_free (s->ac_vout);
s->ac_vout = NULL;
tmp = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (s_gui->w_ac_vout));
if (tmp) {
node_ids = g_strsplit (tmp, "V(", 0);
tmp = g_strdup (node_ids[1]);
g_strfreev (node_ids);
if (tmp) {
node_ids = g_strsplit (tmp, ")", 0);
g_free (tmp);
if (node_ids[0])
s->ac_vout = g_strdup (node_ids[0]);
else
s->ac_vout = g_strdup("");
g_strfreev (node_ids);
}
}
if (s->ac_vout == NULL)
s->ac_vout = g_strdup("");
g_free (s->ac_type);
s->ac_type = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (s_gui->w_ac_type));
g_free (s->ac_npoints);
s->ac_npoints = g_strdup (gtk_entry_get_text (GTK_ENTRY (s_gui->w_ac_npoints)));
g_free (s->ac_start);
s->ac_start = g_strdup (gtk_entry_get_text (GTK_ENTRY (s_gui->w_ac_start)));
g_free (s->ac_stop);
s->ac_stop = g_strdup (gtk_entry_get_text (GTK_ENTRY (s_gui->w_ac_stop)));
// Fourier analysis
s->fourier_enable = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (s_gui->w_four_enable));
g_free (s->fourier_frequency);
s->fourier_frequency = g_strdup (gtk_entry_get_text (GTK_ENTRY (s_gui->w_four_freq)));
// Noise
s->noise_enable = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (s_gui->w_noise_enable));
g_free (s->noise_vin);
s->noise_vin = NULL;
tmp = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (s_gui->w_noise_vin));
if (tmp) {
node_ids = g_strsplit (tmp, "V(", 0);
tmp = g_strdup (node_ids[1]);
g_strfreev (node_ids);
if (tmp) {
node_ids = g_strsplit (tmp, ")", 0);
g_free (tmp);
if (node_ids[0])
s->noise_vin = g_strdup (node_ids[0]);
else
s->noise_vin = g_strdup("");
g_strfreev (node_ids);
}
}
if (s->noise_vin == NULL)
s->noise_vin = g_strdup("");
g_free (s->noise_vout);
s->noise_vout = NULL;
tmp = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (s_gui->w_noise_vout));
if (tmp) {
node_ids = g_strsplit (tmp, "V(", 0);
tmp = g_strdup (node_ids[1]);
g_strfreev (node_ids);
if (tmp) {
node_ids = g_strsplit (tmp, ")", 0);
g_free (tmp);
if (node_ids[0])
s->noise_vout = g_strdup (node_ids[0]);
else
s->noise_vout = g_strdup("");
g_strfreev (node_ids);
}
}
if (s->noise_vout == NULL)
s->noise_vout = g_strdup("");
g_free (s->noise_type);
s->noise_type = g_strdup (gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (s_gui->w_noise_type)));
g_free (s->noise_npoints);
s->noise_npoints = g_strdup (gtk_entry_get_text (GTK_ENTRY (s_gui->w_noise_npoints)));
g_free (s->noise_start);
s->noise_start = g_strdup (gtk_entry_get_text (GTK_ENTRY (s_gui->w_noise_start)));
g_free (s->noise_stop);
s->noise_stop = g_strdup (gtk_entry_get_text (GTK_ENTRY (s_gui->w_noise_stop)));
// Options
get_options_from_list (s_gui);
gtk_widget_hide (GTK_WIDGET (s_gui->pbox));
s_gui->pbox = NULL;
s_gui->notebook = NULL;
// Schematic is dirty now ;-)
schematic_set_dirty (sm, TRUE);
s->configured = TRUE;
// The simulation settings configuration has
// been triggered by an attempt to lauch the
// simulation for the first time without
// configuring it first.
if (s->simulation_requested) {
s->simulation_requested = FALSE;
schematic_view_simulate_cmd (NULL, sv);
}
}
