void Example_markers::on_marker_style_changed(Papyrus::MarkerPosition which)
{
int style;
style = m_start_combobox.get_active_row_number();
if ( style < 0 ) return;
m_line->marker(which)->set_style((Papyrus::Marker::Style)style);
}
//------------------------------------------------------------------------------
void mforms::gtk::ToolBarImpl::set_selector_items(ToolBarItem *item, const std::vector<std::string> &values) {
if (item->get_type() == mforms::SelectorItem || item->get_type() == mforms::FlatSelectorItem) {
Gtk::ComboBoxText *w = cast<Gtk::ComboBoxText *>(item->get_data_ptr());
if (w) {
w->set_data("ignore_signal", (void *)1);
#if ((GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 24) || GTKMM_MAJOR_VERSION > 2)
w->remove_all();
#else
w->clear_items();
#endif
const int size = values.size();
for (int i = 0; i < size; ++i)
w->append(values[i]);
if (w->get_active_row_number() < 0 && !values.empty())
w->set_active_text(values[0]);
w->set_data("ignore_signal", 0);
}
} else if (item->get_type() == mforms::ColorSelectorItem) {
Gtk::ComboBox *w = cast<Gtk::ComboBox *>(item->get_data_ptr());
if (w) {
w->set_data("ignore_signal", (void *)1);
Glib::RefPtr<Gtk::ListStore> model = Gtk::ListStore::create(*color_combo_columns);
const int size = values.size();
for (int i = 0; i < size; ++i) {
Gtk::TreeRow row = *model->append();
Gdk::Color color(values[i]);
Glib::RefPtr<Gdk::Pixbuf> pixbuf = Gdk::Pixbuf::create(Gdk::COLORSPACE_RGB, false, 8, 16, 14);
pixbuf->fill((guint32)color.get_red() << 24 | (guint32)color.get_green() << 16 | (guint32)color.get_blue() << 8);
row[color_combo_columns->color] = values[i];
row[color_combo_columns->image] = pixbuf;
}
w->set_model(model);
if (w->get_active_row_number() < 0)
w->set_active(0);
w->set_data("ignore_signal", 0);
}
}
}
void DimensionManager::addDimension() {
Gtk::Dialog dialog(_("New Dimension"), true /*modal*/);
// add dimension type combo box to the dialog
Glib::RefPtr<Gtk::ListStore> refComboModel = Gtk::ListStore::create(comboModel);
for (int i = 0x01; i < 0xff; i++) {
Glib::ustring sType =
dimTypeAsString(static_cast<gig::dimension_t>(i));
if (sType.find("Unknown") != 0) {
Gtk::TreeModel::Row row = *(refComboModel->append());
row[comboModel.m_type_id] = i;
row[comboModel.m_type_name] = sType;
}
}
Gtk::Table table(2, 2);
Gtk::Label labelDimType(_("Dimension:"), Gtk::ALIGN_START);
Gtk::ComboBox comboDimType;
comboDimType.set_model(refComboModel);
comboDimType.pack_start(comboModel.m_type_id);
comboDimType.pack_start(comboModel.m_type_name);
Gtk::Label labelZones(_("Zones:"), Gtk::ALIGN_START);
table.attach(labelDimType, 0, 1, 0, 1);
table.attach(comboDimType, 1, 2, 0, 1);
table.attach(labelZones, 0, 1, 1, 2);
dialog.get_vbox()->pack_start(table);
// number of zones: use a combo box with fix values for gig
// v2 and a spin button for v3
Gtk::ComboBoxText comboZones;
Gtk::SpinButton spinZones;
bool version2 = false;
if (region) {
gig::File* file = (gig::File*)region->GetParent()->GetParent();
version2 = file->pVersion && file->pVersion->major == 2;
}
if (version2) {
for (int i = 1; i <= 5; i++) {
char buf[3];
sprintf(buf, "%d", 1 << i);
#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 24) || GTKMM_MAJOR_VERSION < 2
comboZones.append_text(buf);
#else
comboZones.append(buf);
#endif
}
table.attach(comboZones, 1, 2, 1, 2);
} else {
spinZones.set_increments(1, 8);
spinZones.set_numeric(true);
spinZones.set_range(2, 128);
spinZones.set_value(2);
table.attach(spinZones, 1, 2, 1, 2);
}
dialog.add_button(_("_OK"), 0);
dialog.add_button(_("_Cancel"), 1);
dialog.show_all_children();
if (!dialog.run()) { // OK selected ...
Gtk::TreeModel::iterator iterType = comboDimType.get_active();
if (!iterType) return;
Gtk::TreeModel::Row rowType = *iterType;
if (!rowType) return;
int iTypeID = rowType[comboModel.m_type_id];
gig::dimension_t type = static_cast<gig::dimension_t>(iTypeID);
gig::dimension_def_t dim;
dim.dimension = type;
if (version2) {
if (comboZones.get_active_row_number() < 0) return;
dim.bits = comboZones.get_active_row_number() + 1;
dim.zones = 1 << dim.bits;
} else {
dim.zones = spinZones.get_value_as_int();
dim.bits = zoneCountToBits(dim.zones);
}
// assemble the list of regions where the selected dimension shall be
// added to
std::vector<gig::Region*> vRegions;
if (allRegions()) {
gig::Instrument* instr = (gig::Instrument*)region->GetParent();
for (gig::Region* rgn = instr->GetFirstRegion(); rgn; rgn = instr->GetNextRegion()) {
if (!rgn->GetDimensionDefinition(type)) vRegions.push_back(rgn);
}
} else vRegions.push_back(region);
std::set<Glib::ustring> errors;
for (uint iRgn = 0; iRgn < vRegions.size(); ++iRgn) {
gig::Region* region = vRegions[iRgn];
try {
printf(
"Adding dimension (type=0x%x, bits=%d, zones=%d)\n",
dim.dimension, dim.bits, dim.zones
);
// notify everybody that we're going to update the region
region_to_be_changed_signal.emit(region);
// add the new dimension to the region
// (implicitly creates new dimension regions)
region->AddDimension(&dim);
// let everybody know there was a change
region_changed_signal.emit(region);
} catch (RIFF::Exception e) {
// notify that the changes are over (i.e. to avoid dead locks)
region_changed_signal.emit(region);
Glib::ustring txt = _("Could not add dimension: ") + e.Message;
if (vRegions.size() == 1) {
// show error message directly
Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
msg.run();
} else {
// remember error, they are shown after all regions have been processed
errors.insert(txt);
}
}
}
// update all GUI elements
refreshManager();
if (!errors.empty()) {
Glib::ustring txt = _(
"The following errors occurred while trying to create the dimension on all regions:"
);
txt += "\n\n";
for (std::set<Glib::ustring>::const_iterator it = errors.begin();
it != errors.end(); ++it)
{
txt += "-> " + *it + "\n";
}
txt += "\n";
txt += _(
"You might also want to check the console for further warnings and "
"error messages."
);
Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
msg.run();
}
}
}
static void OnChangeFCWFilter(Gtk::ComboBoxText& combo, Gtk::FileChooserWidget& fcw)
{
FCWFilterType typ = (FCWFilterType)combo.get_active_row_number();
SetFilter(fcw, typ);
}
Window() :
show_edges_label("Show edges"),
show_labels_label("Show contour labels"),
edge_color_label("Contour edge color"),
edge_color(Gdk::RGBA("Red")),
edge_width_label("Contour edge width"),
edge_width_adj(Gtk::Adjustment::create(1.0, 0.1, 10.0, 0.1, 1.0, 0.0)),
edge_width_spin(edge_width_adj, 0.1, 1),
nlevels_label("Number of contour edges"),
nlevels_adj(Gtk::Adjustment::create(7, 3, 20, 1, 5)),
nlevels_spin(nlevels_adj, 1, 0),
colormap_palette_label("Colormap palette"),
area_fill_pattern_label("Fill pattern"),
area_lines_width_label("Fill pattern width"),
area_lines_width_adj(Gtk::Adjustment::create(1.0, 0.1, 10.0, 0.1, 1.0, 0.0)),
area_lines_width_spin(area_lines_width_adj, 0.1, 1),
colorbar_label("Show colorbar"),
paned(Gtk::ORIENTATION_VERTICAL),
aspect_frame(Glib::ustring(), Gtk::ALIGN_CENTER, Gtk::ALIGN_CENTER, 1.5, false)
{
Glib::ustring x_title = "X-axis";
Glib::ustring y_title = "Y-axis";
Glib::ustring plot_title = "Intensity vs detector position";
// general window and canvas settings
set_default_size(720, 720);
Gdk::Geometry geometry;
geometry.min_aspect = geometry.max_aspect = double(720)/double(720);
set_geometry_hints(*this, geometry, Gdk::HINT_ASPECT);
set_title("Gtkmm-PLplot test8");
canvas.set_hexpand(true);
canvas.set_vexpand(true);
//read in our dataset
std::ifstream fs;
fs.exceptions(std::ifstream::failbit | std::ifstream::badbit | std::ifstream::eofbit);
// 11 x 11 dataset (I know the file layout and the data dimensions already)
const int nx = 11;
const int ny = 11;
std::vector<double> x(nx);
std::vector<double> y(ny);
#ifdef GTKMM_PLPLOT_BOOST_ENABLED
boost::multi_array<double, 2> z(boost::extents[nx][ny]);
std::cout << "Using Boost multi_array!" << std::endl;
#else
double **z = Gtk::PLplot::calloc_array2d(nx, ny);
#endif
fs.open(TEST_CSV);
std::string line;
std::getline(fs, line);
gchar **splitted = g_strsplit(line.c_str(), ",", 0);
//first line contains the x values
for (int i = 1 ; i < nx + 1 ; i++) {
x[i-1] = g_ascii_strtod(splitted[i], NULL);
}
g_strfreev(splitted);
for (int i = 0 ; i < ny ; i++) {
line.clear();
std::getline(fs, line);
splitted = g_strsplit(line.c_str(), ",", 0);
y[i] = g_ascii_strtod(splitted[0], NULL);
for (int j = 1 ; j < nx + 1 ; j++) {
z[j-1][i] = g_ascii_strtod(splitted[j], NULL);
}
g_strfreev(splitted);
}
//construct the plot
auto plot = Gtk::manage(new Gtk::PLplot::PlotContourShades(
*Gtk::manage(new Gtk::PLplot::PlotDataSurface(
x,
y,
z
)),
x_title,
y_title,
plot_title,
7,
Gtk::PLplot::ColormapPalette::BLUE_RED,
edge_color.get_rgba(),
1.0
));
canvas.add_plot(*plot);
plot->set_background_color(Gdk::RGBA("Yellow Green"));
//now let's set up the grid
grid.set_column_homogeneous(true);
grid.set_column_spacing(5);
grid.set_row_homogeneous(false);
grid.set_row_spacing(5);
int row_counter = 0;
show_edges_label.set_hexpand(true);
show_edges_label.set_vexpand(false);
show_edges_label.set_valign(Gtk::ALIGN_CENTER);
show_edges_label.set_halign(Gtk::ALIGN_END);
show_edges_switch.set_hexpand(true);
show_edges_switch.set_vexpand(false);
show_edges_switch.set_halign(Gtk::ALIGN_START);
show_edges_switch.set_valign(Gtk::ALIGN_CENTER);
show_edges_switch.set_active(plot->is_showing_edges());
show_edges_switch.property_active().signal_changed().connect([this, plot](){
if (show_edges_switch.get_active()) {
edge_color.set_sensitive();
edge_width_spin.set_sensitive();
show_labels_switch.set_sensitive();
plot->show_edges();
}
else {
edge_color.set_sensitive(false);
edge_width_spin.set_sensitive(false);
show_labels_switch.set_sensitive(false);
plot->hide_edges();
}
});
grid.attach(show_edges_label, 0, row_counter, 1, 1);
grid.attach(show_edges_switch, 1, row_counter++, 1, 1);
// show contour labels
show_labels_label.set_hexpand(true);
show_labels_label.set_vexpand(false);
show_labels_label.set_valign(Gtk::ALIGN_CENTER);
show_labels_label.set_halign(Gtk::ALIGN_END);
show_labels_switch.set_hexpand(true);
show_labels_switch.set_vexpand(false);
show_labels_switch.set_halign(Gtk::ALIGN_START);
show_labels_switch.set_valign(Gtk::ALIGN_CENTER);
show_labels_switch.set_active(plot->is_showing_labels());
show_labels_switch.property_active().signal_changed().connect([this, plot](){
if (show_labels_switch.get_active()) {
plot->show_labels();
}
else {
plot->hide_labels();
}
});
grid.attach(show_labels_label, 0, row_counter, 1, 1);
grid.attach(show_labels_switch, 1, row_counter++, 1, 1);
//color button
edge_color_label.set_hexpand(true);
edge_color_label.set_vexpand(false);
edge_color_label.set_valign(Gtk::ALIGN_CENTER);
edge_color_label.set_halign(Gtk::ALIGN_END);
edge_color.set_rgba(plot->get_edge_color());
edge_color.set_use_alpha(true);
edge_color.set_hexpand(true);
edge_color.set_vexpand(false);
edge_color.set_halign(Gtk::ALIGN_START);
edge_color.set_valign(Gtk::ALIGN_CENTER);
edge_color.signal_color_set().connect([this, plot](){plot->set_edge_color(edge_color.get_rgba());});
grid.attach(edge_color_label, 0, row_counter, 1, 1);
grid.attach(edge_color, 1, row_counter++, 1, 1);
//the edge width spinbutton
edge_width_label.set_hexpand(true);
edge_width_label.set_vexpand(false);
edge_width_label.set_valign(Gtk::ALIGN_CENTER);
edge_width_label.set_halign(Gtk::ALIGN_END);
edge_width_spin.set_hexpand(true);
edge_width_spin.set_vexpand(false);
edge_width_spin.set_halign(Gtk::ALIGN_START);
edge_width_spin.set_valign(Gtk::ALIGN_CENTER);
edge_width_spin.set_wrap(true);
edge_width_spin.set_snap_to_ticks(true);
edge_width_spin.set_numeric(true);
edge_width_spin.set_value(plot->get_edge_width());
edge_width_spin.signal_value_changed().connect([this, plot](){
plot->set_edge_width(edge_width_spin.get_value());
});
grid.attach(edge_width_label, 0, row_counter, 1, 1);
grid.attach(edge_width_spin, 1, row_counter++, 1, 1);
//nlevels
nlevels_label.set_hexpand(true);
nlevels_label.set_vexpand(false);
nlevels_label.set_valign(Gtk::ALIGN_CENTER);
nlevels_label.set_halign(Gtk::ALIGN_END);
nlevels_spin.set_hexpand(true);
nlevels_spin.set_vexpand(false);
nlevels_spin.set_halign(Gtk::ALIGN_START);
nlevels_spin.set_valign(Gtk::ALIGN_CENTER);
nlevels_spin.set_wrap(true);
nlevels_spin.set_snap_to_ticks(true);
nlevels_spin.set_numeric(true);
nlevels_spin.set_value(plot->get_nlevels());
nlevels_spin.signal_value_changed().connect([this, plot](){
plot->set_nlevels(nlevels_spin.get_value());
});
grid.attach(nlevels_label, 0, row_counter, 1, 1);
grid.attach(nlevels_spin, 1, row_counter++, 1, 1);
// colormap palette
colormap_palette_label.set_hexpand(true);
colormap_palette_label.set_vexpand(false);
colormap_palette_label.set_valign(Gtk::ALIGN_CENTER);
colormap_palette_label.set_halign(Gtk::ALIGN_END);
colormap_palette_combo.set_hexpand(true);
colormap_palette_combo.set_vexpand(false);
colormap_palette_combo.set_halign(Gtk::ALIGN_START);
colormap_palette_combo.set_valign(Gtk::ALIGN_CENTER);
colormap_palette_combo.append("Default");
colormap_palette_combo.append("Blue → Red");
colormap_palette_combo.append("Blue → Yellow");
colormap_palette_combo.append("Gray");
colormap_palette_combo.append("High frequencies");
colormap_palette_combo.append("Low frequencies");
colormap_palette_combo.append("Radar");
colormap_palette_combo.set_active(plot->get_colormap_palette());
colormap_palette_combo.signal_changed().connect([this, plot](){
plot->set_colormap_palette(static_cast<Gtk::PLplot::ColormapPalette>(colormap_palette_combo.get_active_row_number()));
});
grid.attach(colormap_palette_label, 0, row_counter, 1, 1);
grid.attach(colormap_palette_combo, 1, row_counter++, 1, 1);
//area fill pattern
area_fill_pattern_label.set_hexpand(true);
area_fill_pattern_label.set_vexpand(false);
area_fill_pattern_label.set_valign(Gtk::ALIGN_CENTER);
area_fill_pattern_label.set_halign(Gtk::ALIGN_END);
area_fill_pattern_combo.set_hexpand(true);
area_fill_pattern_combo.set_vexpand(false);
area_fill_pattern_combo.set_halign(Gtk::ALIGN_START);
area_fill_pattern_combo.set_valign(Gtk::ALIGN_CENTER);
area_fill_pattern_combo.append("Solid");
area_fill_pattern_combo.append("Horizontal lines");
area_fill_pattern_combo.append("Vertical lines");
area_fill_pattern_combo.append("Upward lines at 45 degrees");
area_fill_pattern_combo.append("Downward lines at 45 degrees");
area_fill_pattern_combo.append("Upward lines at 30 degrees");
area_fill_pattern_combo.append("Downward lines at 30 degrees");
area_fill_pattern_combo.append("Horizontal and vertical lines");
area_fill_pattern_combo.append("Upward and downward lines at 45 degrees");
area_fill_pattern_combo.set_active(plot->get_area_fill_pattern());
area_fill_pattern_combo.signal_changed().connect([this, plot](){
plot->set_area_fill_pattern(static_cast<Gtk::PLplot::AreaFillPattern>(area_fill_pattern_combo.get_active_row_number()));
if (area_fill_pattern_combo.get_active_row_number() == 0 /* SOLID */) {
area_lines_width_spin.set_sensitive(false);
}
else {
area_lines_width_spin.set_sensitive();
}
});
grid.attach(area_fill_pattern_label, 0, row_counter, 1, 1);
grid.attach(area_fill_pattern_combo, 1, row_counter++, 1, 1);
//the area lines width spinbutton
area_lines_width_label.set_hexpand(true);
area_lines_width_label.set_vexpand(false);
area_lines_width_label.set_valign(Gtk::ALIGN_CENTER);
area_lines_width_label.set_halign(Gtk::ALIGN_END);
area_lines_width_spin.set_hexpand(true);
area_lines_width_spin.set_vexpand(false);
area_lines_width_spin.set_halign(Gtk::ALIGN_START);
area_lines_width_spin.set_valign(Gtk::ALIGN_CENTER);
area_lines_width_spin.set_wrap(true);
area_lines_width_spin.set_snap_to_ticks(true);
area_lines_width_spin.set_numeric(true);
area_lines_width_spin.set_value(plot->get_area_lines_width());
area_lines_width_spin.signal_value_changed().connect([this, plot](){
plot->set_area_lines_width(area_lines_width_spin.get_value());
});
area_lines_width_spin.set_sensitive(false);
grid.attach(area_lines_width_label, 0, row_counter, 1, 1);
grid.attach(area_lines_width_spin, 1, row_counter++, 1, 1);
//colorbar
colorbar_label.set_hexpand(true);
colorbar_label.set_vexpand(false);
colorbar_label.set_valign(Gtk::ALIGN_CENTER);
colorbar_label.set_halign(Gtk::ALIGN_END);
colorbar_switch.set_hexpand(true);
colorbar_switch.set_vexpand(false);
colorbar_switch.set_halign(Gtk::ALIGN_START);
colorbar_switch.set_valign(Gtk::ALIGN_CENTER);
colorbar_switch.set_active(plot->is_showing_colorbar());
colorbar_switch.property_active().signal_changed().connect([this, plot](){
if (colorbar_switch.get_active()) {
plot->show_colorbar();
}
else {
plot->hide_colorbar();
}
});
grid.attach(colorbar_label, 0, row_counter, 1, 1);
grid.attach(colorbar_switch, 1, row_counter++, 1, 1);
paned.add1(grid);
//add canvas to grid
aspect_frame.add(canvas);
paned.add2(aspect_frame);
//finishing up
add(paned);
set_border_width(10);
#if GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION >= 18
paned.set_wide_handle(true);
#endif
paned.show_all();
}