static void
update_length(GtkVlcPlayer *player, gint64 new_length)
{
g_signal_emit(player, gtk_vlc_player_signals[LENGTH_CHANGED_SIGNAL], 0,
new_length);
if (player->priv->time_adjustment != NULL) {
GtkAdjustment *adj = GTK_ADJUSTMENT(player->priv->time_adjustment);
/* ensure that time_adj_on_changed() will not be executed */
g_signal_handler_block(G_OBJECT(adj),
player->priv->time_adj_on_changed_id);
gtk_adjustment_set_upper(adj, (gdouble)new_length +
gtk_adjustment_get_page_size(adj));
g_signal_handler_unblock(G_OBJECT(adj),
player->priv->time_adj_on_changed_id);
}
}
void
fe_get_int (char *msg, int def, void *callback, void *userdata)
{
GtkWidget *dialog;
GtkWidget *spin;
GtkWidget *hbox;
GtkWidget *label;
GtkAdjustment *adj;
extern GtkWidget *parent_window;
dialog = gtk_dialog_new_with_buttons (msg, NULL, 0,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL);
gtk_box_set_homogeneous (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), TRUE);
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent_window));
hbox = gtk_hbox_new (TRUE, 0);
g_object_set_data (G_OBJECT (dialog), "cb", callback);
g_object_set_data (G_OBJECT (dialog), "ud", userdata);
spin = gtk_spin_button_new (NULL, 1, 0);
adj = gtk_spin_button_get_adjustment ((GtkSpinButton*)spin);
gtk_adjustment_set_lower (adj, 0);
gtk_adjustment_set_upper (adj, 1024);
gtk_adjustment_set_step_increment (adj, 1);
gtk_adjustment_changed (adj);
gtk_spin_button_set_value ((GtkSpinButton*)spin, def);
gtk_box_pack_end (GTK_BOX (hbox), spin, 0, 0, 0);
label = gtk_label_new (msg);
gtk_box_pack_end (GTK_BOX (hbox), label, 0, 0, 0);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (gtkutil_get_number_response), spin);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox);
gtk_widget_show_all (dialog);
}
static void
dma_sparse_view_set_scroll_adjustments (GtkTextView *text_view,
GtkAdjustment *hadj,
GtkAdjustment *vadj)
{
DmaSparseView *view = DMA_SPARSE_VIEW (text_view);
if (vadj)
g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
if (view->priv->vadjustment && (view->priv->vadjustment != vadj))
{
g_signal_handlers_disconnect_by_func (view->priv->vadjustment,
dma_sparse_view_value_changed,
view);
g_object_unref (view->priv->vadjustment);
}
if (view->priv->vadjustment != vadj)
{
GTK_TEXT_VIEW_CLASS (parent_class)->set_scroll_adjustments (GTK_TEXT_VIEW (view), hadj, NULL);
if (vadj != NULL)
{
g_object_ref_sink (vadj);
g_signal_connect (vadj, "value_changed",
G_CALLBACK (dma_sparse_view_value_changed),
view);
gtk_adjustment_set_upper (vadj, dma_sparse_buffer_get_upper (view->priv->buffer));
gtk_adjustment_set_lower (vadj, dma_sparse_buffer_get_lower (view->priv->buffer));
gtk_adjustment_set_value (vadj, 0);
}
view->priv->vadjustment = vadj;
dma_sparse_view_update_adjustement (view);
}
}
void texture_init() {
init_treeview(builder, "texture_list_treeview", 1);
init_treeview(builder, "selected_texture_treeview", 2);
//Initialize texture image view
GObject* tex_image_view = gtk_builder_get_object(builder, "selected_texture_images");
GtkTreeStore* store = gtk_tree_store_new(2, G_TYPE_STRING, GDK_TYPE_PIXBUF);
gtk_tree_view_set_model(GTK_TREE_VIEW(tex_image_view),
GTK_TREE_MODEL(store));
g_object_unref(store);
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn* column = gtk_tree_view_get_column(GTK_TREE_VIEW(tex_image_view), 0);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer, "text", 0, NULL);
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_get_column(GTK_TREE_VIEW(tex_image_view), 1);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer, "pixbuf", 1, NULL);
//Initialize face combobox
GObject* face = gtk_builder_get_object(builder, "face_combobox");
GtkTreeStore* face_store = gtk_tree_store_new(1, G_TYPE_STRING);
gtk_combo_box_set_model(GTK_COMBO_BOX(face), GTK_TREE_MODEL(face_store));
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(face), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(face), renderer, "text", 0, NULL);
GtkTreeIter row;
const char* strs[] = {"Positive X", "Negative X", "Positive Y", "Negative Y", "Positive Z", "Negative Z"};
for (size_t i = 0; i < sizeof(strs)/sizeof(strs[0]); i++) {
gtk_tree_store_append(face_store, &row, NULL);
gtk_tree_store_set(face_store, &row, 0, strs[i], -1);
}
g_object_unref(face_store);
gtk_combo_box_set_active(GTK_COMBO_BOX(face), 0);
//Initialize layer
GtkSpinButton* button = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "layer_spinbutton"));
gtk_adjustment_set_upper(gtk_spin_button_get_adjustment(button), 0);
}
static void xhairs_length_add_marks (GtkScale *scale)
{
gint length, quarter_length;
GtkAdjustment *scale_model;
/* Get maximum dimension of screen */
length = MAX(gdk_screen_width(), gdk_screen_height());
scale_model = gtk_range_get_adjustment (GTK_RANGE (scale));
if (length < gtk_adjustment_get_upper(scale_model))
{
gtk_adjustment_set_upper (scale_model, length);
}
/* The crosshair is made up of four lines in pairs (top, bottom) and
(left, right). Stipulating: "quarter of the screen" means that the
length of one hair is 25% of the screen. */
quarter_length = length / 4;
gtk_scale_add_mark (scale, 0, GTK_POS_BOTTOM, C_("Distance", "Short"));
gtk_scale_add_mark (scale, quarter_length, GTK_POS_BOTTOM, C_("Distance", "¼ Screen"));
gtk_scale_add_mark (scale, quarter_length * 2 , GTK_POS_BOTTOM, C_("Distance", "½ Screen"));
gtk_scale_add_mark (scale, quarter_length * 3, GTK_POS_BOTTOM, C_("Distance", "¾ Screen"));
gtk_scale_add_mark (scale, length, GTK_POS_BOTTOM, C_("Distance", "Long"));
}
static void
cb_show_details (GtkWidget *button,
AppearanceData *data)
{
if (!data->font_details) {
GtkAdjustment *adjustment;
GtkWidget *widget;
EnumGroup *group;
data->font_details = appearance_capplet_get_widget (data, "render_details");
gtk_window_set_transient_for (GTK_WINDOW (data->font_details),
GTK_WINDOW (appearance_capplet_get_widget (data, "appearance_window")));
widget = appearance_capplet_get_widget (data, "dpi_spinner");
/* pick a sensible maximum dpi */
adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
gtk_adjustment_set_lower (adjustment, DPI_LOW_REASONABLE_VALUE);
gtk_adjustment_set_upper (adjustment, DPI_HIGH_REASONABLE_VALUE);
gtk_adjustment_set_step_increment (adjustment, 1);
dpi_load (data->font_settings, GTK_SPIN_BUTTON (widget));
g_signal_connect (widget, "value_changed",
G_CALLBACK (dpi_value_changed), data->font_settings);
g_signal_connect (data->font_settings, "changed::" FONT_DPI_KEY, G_CALLBACK (dpi_changed), widget);
setup_font_sample (appearance_capplet_get_widget (data, "antialias_none_sample"), ANTIALIAS_NONE, HINT_FULL);
setup_font_sample (appearance_capplet_get_widget (data, "antialias_grayscale_sample"), ANTIALIAS_GRAYSCALE, HINT_FULL);
setup_font_sample (appearance_capplet_get_widget (data, "antialias_subpixel_sample"), ANTIALIAS_RGBA, HINT_FULL);
group = enum_group_create (
data->font_settings, FONT_ANTIALIASING_KEY,
appearance_capplet_get_widget (data, "antialias_none_radio"), ANTIALIAS_NONE,
appearance_capplet_get_widget (data, "antialias_grayscale_radio"), ANTIALIAS_GRAYSCALE,
appearance_capplet_get_widget (data, "antialias_subpixel_radio"), ANTIALIAS_RGBA,
NULL);
data->font_groups = g_slist_prepend (data->font_groups, group);
setup_font_sample (appearance_capplet_get_widget (data, "hint_none_sample"), ANTIALIAS_GRAYSCALE, HINT_NONE);
setup_font_sample (appearance_capplet_get_widget (data, "hint_slight_sample"), ANTIALIAS_GRAYSCALE, HINT_SLIGHT);
setup_font_sample (appearance_capplet_get_widget (data, "hint_medium_sample"), ANTIALIAS_GRAYSCALE, HINT_MEDIUM);
setup_font_sample (appearance_capplet_get_widget (data, "hint_full_sample"), ANTIALIAS_GRAYSCALE, HINT_FULL);
group = enum_group_create (data->font_settings, FONT_HINTING_KEY,
appearance_capplet_get_widget (data, "hint_none_radio"), HINT_NONE,
appearance_capplet_get_widget (data, "hint_slight_radio"), HINT_SLIGHT,
appearance_capplet_get_widget (data, "hint_medium_radio"), HINT_MEDIUM,
appearance_capplet_get_widget (data, "hint_full_radio"), HINT_FULL,
NULL);
data->font_groups = g_slist_prepend (data->font_groups, group);
gtk_image_set_from_file (GTK_IMAGE (appearance_capplet_get_widget (data, "subpixel_rgb_image")),
MATECC_PIXMAP_DIR "/subpixel-rgb.png");
gtk_image_set_from_file (GTK_IMAGE (appearance_capplet_get_widget (data, "subpixel_bgr_image")),
MATECC_PIXMAP_DIR "/subpixel-bgr.png");
gtk_image_set_from_file (GTK_IMAGE (appearance_capplet_get_widget (data, "subpixel_vrgb_image")),
MATECC_PIXMAP_DIR "/subpixel-vrgb.png");
gtk_image_set_from_file (GTK_IMAGE (appearance_capplet_get_widget (data, "subpixel_vbgr_image")),
MATECC_PIXMAP_DIR "/subpixel-vbgr.png");
group = enum_group_create (data->font_settings, FONT_RGBA_ORDER_KEY,
appearance_capplet_get_widget (data, "subpixel_rgb_radio"), RGBA_RGB,
appearance_capplet_get_widget (data, "subpixel_bgr_radio"), RGBA_BGR,
appearance_capplet_get_widget (data, "subpixel_vrgb_radio"), RGBA_VRGB,
appearance_capplet_get_widget (data, "subpixel_vbgr_radio"), RGBA_VBGR,
NULL);
data->font_groups = g_slist_prepend (data->font_groups, group);
g_signal_connect (G_OBJECT (data->font_details),
"response",
G_CALLBACK (cb_details_response), NULL);
g_signal_connect (G_OBJECT (data->font_details),
"delete_event",
G_CALLBACK (gtk_true), NULL);
}
gtk_window_present (GTK_WINDOW (data->font_details));
}
static void
set_up_quantity(GFilterControls *controls, GwyGrainValue *gvalue, guint id)
{
GFilterArgs *args = controls->args;
GwyInventory *inventory;
GwyDataField *dfield;
RangeRecord *rr;
const gchar *name;
const gdouble *v;
gchar *s, *t;
gdouble vmin, vmax, lower = -G_MAXDOUBLE, upper = G_MAXDOUBLE;
GwySIUnit *siunit, *siunitxy, *siunitz;
gboolean was_in_init = controls->in_init;
guint i, nuniq;
controls->in_init = TRUE;
name = gwy_resource_get_name(GWY_RESOURCE(gvalue));
args->ranges[id].quantity = name;
/* TRANSLATORS: %c is replaced with quantity label A, B or C. */
s = g_strdup_printf(_("Condition %c: %s"), 'A' + id, name);
t = g_strconcat("<b>", s, "</b>", NULL);
gtk_label_set_markup(GTK_LABEL(controls->header[id]), t);
g_free(t);
g_free(s);
rr = g_hash_table_lookup(args->ranges_history, (gpointer)name);
if (rr) {
lower = rr->lower;
upper = rr->upper;
}
inventory = gwy_grain_values();
i = gwy_inventory_get_item_position(inventory, name);
nuniq = args->nuniqvalues[i];
v = g_ptr_array_index(args->sortedvaluedata, i);
vmin = v[0];
vmax = v[nuniq-1];
lower = CLAMP(lower, vmin, vmax);
upper = CLAMP(upper, vmin, vmax);
gtk_adjustment_set_upper(GTK_ADJUSTMENT(controls->lower[id]), nuniq-1);
gtk_adjustment_set_upper(GTK_ADJUSTMENT(controls->upper[id]), nuniq-1);
dfield = gwy_container_get_object_by_name(controls->mydata, "/0/data");
siunitxy = gwy_data_field_get_si_unit_xy(dfield);
siunitz = gwy_data_field_get_si_unit_z(dfield);
siunit = gwy_si_unit_power_multiply(siunitxy,
gwy_grain_value_get_power_xy(gvalue),
siunitz,
gwy_grain_value_get_power_z(gvalue),
NULL);
gwy_si_unit_get_format_with_digits(siunit, GWY_SI_UNIT_FORMAT_VFMARKUP,
MAX(fabs(vmin), fabs(vmax)), 4,
controls->vf[id]);
g_object_unref(siunit);
/* Special-case the pixel area format. */
if (gwy_strequal(name, "Pixel area")) {
controls->vf[id]->magnitude = 1.0;
controls->vf[id]->precision = 0;
gwy_si_unit_value_format_set_units(controls->vf[id], "");
}
gtk_label_set_markup(GTK_LABEL(controls->lower_units[id]),
controls->vf[id]->units);
gtk_label_set_markup(GTK_LABEL(controls->upper_units[id]),
controls->vf[id]->units);
args->ranges[id].quantity = name;
args->ranges[id].lower = lower;
args->ranges[id].upper = upper;
set_adjustment_to_grain_value(controls, gvalue,
GTK_ADJUSTMENT(controls->lower[id]), lower);
set_adjustment_to_grain_value(controls, gvalue,
GTK_ADJUSTMENT(controls->upper[id]), upper);
s = g_strdup_printf("%.*f",
controls->vf[id]->precision,
lower/controls->vf[id]->magnitude);
gtk_entry_set_text(GTK_ENTRY(controls->lower_entry[id]), s);
g_free(s);
s = g_strdup_printf("%.*f",
controls->vf[id]->precision,
upper/controls->vf[id]->magnitude);
gtk_entry_set_text(GTK_ENTRY(controls->upper_entry[id]), s);
g_free(s);
/* XXX: We might have modified the range by CLAMP(). Store the new one
* right here? Pro: consistency. Con: the user did not do anything,
* he just may be browsing. */
controls->in_init = was_in_init;
gfilter_invalidate(controls);
}
extern struct view_s* window_new(const char* name, long* pos, const long dims[DIMS], const complex float* x)
{
struct view_s* v = create_view(name, pos, dims, x);
GtkBuilder* builder = gtk_builder_new();
// gtk_builder_add_from_file(builder, "viewer.ui", NULL);
gtk_builder_add_from_string(builder, viewer_gui, -1, NULL);
v->gtk_drawingarea = GTK_WIDGET(gtk_builder_get_object(builder, "drawingarea1"));
v->gtk_viewport = GTK_WIDGET(gtk_builder_get_object(builder, "scrolledwindow1"));
v->gtk_winlow = GTK_ADJUSTMENT(gtk_builder_get_object(builder, "winlow"));
v->gtk_winhigh = GTK_ADJUSTMENT(gtk_builder_get_object(builder, "winhigh"));
v->gtk_entry = GTK_ENTRY(gtk_builder_get_object(builder, "entry"));
PangoFontDescription* desc = pango_font_description_new();
pango_font_description_set_family(desc, "mono");
pango_font_description_set_weight(desc, PANGO_WEIGHT_BOLD);
pango_font_description_set_absolute_size(desc, 10 * PANGO_SCALE);
gtk_widget_override_font(GTK_WIDGET(v->gtk_entry), desc);
pango_font_description_free(desc);
v->gtk_zoom = GTK_ADJUSTMENT(gtk_builder_get_object(builder, "zoom"));
v->gtk_aniso = GTK_ADJUSTMENT(gtk_builder_get_object(builder, "aniso"));
v->gtk_mode = GTK_COMBO_BOX(gtk_builder_get_object(builder, "mode"));
gtk_combo_box_set_active(v->gtk_mode, 0);
v->gtk_flip = GTK_COMBO_BOX(gtk_builder_get_object(builder, "flip"));
gtk_combo_box_set_active(v->gtk_flip, 0);
v->gtk_transpose = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builder, "transpose"));
for (int j = 0; j < DIMS; j++) {
char pname[10];
snprintf(pname, 10, "pos%02d", j);
v->gtk_posall[j] = GTK_ADJUSTMENT(gtk_builder_get_object(builder, pname));
gtk_adjustment_set_upper(v->gtk_posall[j], v->dims[j] - 1);
gtk_adjustment_set_value(v->gtk_posall[j], 0);
snprintf(pname, 10, "check%02d", j);
v->gtk_checkall[j] = GTK_CHECK_BUTTON(gtk_builder_get_object(builder, pname));
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(v->gtk_checkall[v->xdim]), TRUE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(v->gtk_checkall[v->ydim]), TRUE);
gtk_builder_connect_signals(builder, v);
GtkWindow* window = GTK_WINDOW(gtk_builder_get_object(builder, "window1"));
g_object_unref(G_OBJECT(builder));
gtk_window_set_title(window, name);
gtk_widget_show(GTK_WIDGET(window));
nr_windows++;
refresh_callback(NULL, v);
geom_callback(NULL, v);
window_callback(NULL, v);
return v;
}
void
ags_note_edit_reset_horizontally(AgsNoteEdit *note_edit, guint flags)
{
AgsEditor *editor;
editor = (AgsEditor *) gtk_widget_get_ancestor(GTK_WIDGET(note_edit),
AGS_TYPE_EDITOR);
if(editor->selected_machine != NULL){
cairo_t *cr;
gdouble value;
double tact_factor, zoom_factor;
double tact;
value = GTK_RANGE(note_edit->hscrollbar)->adjustment->value;
zoom_factor = 0.25;
tact_factor = exp2(8.0 - (double) gtk_combo_box_get_active(editor->toolbar->zoom));
tact = exp2((double) gtk_combo_box_get_active(editor->toolbar->zoom) - 4.0);
if((AGS_NOTE_EDIT_RESET_WIDTH & flags) != 0){
note_edit->control_unit.control_width = (guint) (((double) note_edit->control_width * zoom_factor * tact));
note_edit->control_current.control_count = (guint) ((double) note_edit->control_unit.control_count * tact);
note_edit->control_current.control_width = (note_edit->control_width * zoom_factor * tact_factor * tact);
note_edit->map_width = (guint) ((double) note_edit->control_current.control_count * (double) note_edit->control_current.control_width);
}
if((AGS_NOTE_EDIT_RESET_HSCROLLBAR & flags) != 0){
GtkWidget *widget;
GtkAdjustment *adjustment;
guint width;
widget = GTK_WIDGET(note_edit->drawing_area);
adjustment = GTK_RANGE(note_edit->hscrollbar)->adjustment;
if(note_edit->map_width > widget->allocation.width){
width = widget->allocation.width;
// gtk_adjustment_set_upper(adjustment, (double) (note_edit->map_width - width));
gtk_adjustment_set_upper(adjustment,
(gdouble) (note_edit->map_width - width));
if(adjustment->value > adjustment->upper)
gtk_adjustment_set_value(adjustment, adjustment->upper);
}else{
width = note_edit->map_width;
gtk_adjustment_set_upper(adjustment, 0.0);
gtk_adjustment_set_value(adjustment, 0.0);
}
note_edit->width = width;
}
/* reset AgsNoteEditControlCurrent */
if(note_edit->map_width > note_edit->width){
note_edit->control_current.x0 = ((guint) round((double) value)) % note_edit->control_current.control_width;
if(note_edit->control_current.x0 != 0){
note_edit->control_current.x0 = note_edit->control_current.control_width - note_edit->control_current.x0;
}
note_edit->control_current.x1 = (note_edit->width - note_edit->control_current.x0) % note_edit->control_current.control_width;
note_edit->control_current.nth_x = (guint) ceil((double)(value) / (double)(note_edit->control_current.control_width));
}else{
note_edit->control_current.x0 = 0;
note_edit->control_current.x1 = 0;
note_edit->control_current.nth_x = 0;
}
/* reset AgsNoteEditControlUnit */
if(note_edit->map_width > note_edit->width){
note_edit->control_unit.x0 = ((guint)round((double) value)) % note_edit->control_unit.control_width;
if(note_edit->control_unit.x0 != 0)
note_edit->control_unit.x0 = note_edit->control_unit.control_width - note_edit->control_unit.x0;
note_edit->control_unit.x1 = (note_edit->width - note_edit->control_unit.x0) % note_edit->control_unit.control_width;
note_edit->control_unit.nth_x = (guint) ceil(round((double) value) / (double) (note_edit->control_unit.control_width));
note_edit->control_unit.stop_x = note_edit->control_unit.nth_x + (note_edit->width - note_edit->control_unit.x0 - note_edit->control_unit.x1) / note_edit->control_unit.control_width;
}else{
note_edit->control_unit.x0 = 0;
note_edit->control_unit.x1 = 0;
note_edit->control_unit.nth_x = 0;
}
/* refresh display */
if(GTK_WIDGET_VISIBLE(editor)){
gdouble position;
cr = gdk_cairo_create(GTK_WIDGET(note_edit->drawing_area)->window);
cairo_push_group(cr);
ags_note_edit_draw_segment(note_edit, cr);
ags_note_edit_draw_notation(note_edit, cr);
if(editor->toolbar->selected_edit_mode == editor->toolbar->position){
ags_note_edit_draw_position(note_edit, cr);
}
//TODO:JK: implement me
// position = gtk_range_get_value(GTK_RANGE(note_edit->hscrollbar));
// position -= floor(position / note_edit->control_current.control_width);
// ags_note_edit_draw_scroll(note_edit, cr,
// position);
cairo_pop_group_to_source(cr);
cairo_paint(cr);
}
}
}
void
ags_note_edit_reset_vertically(AgsNoteEdit *note_edit, guint flags)
{
AgsEditor *editor;
editor = (AgsEditor *) gtk_widget_get_ancestor(GTK_WIDGET(note_edit),
AGS_TYPE_EDITOR);
if(editor->selected_machine != NULL){
cairo_t *cr;
gdouble value;
value = GTK_RANGE(note_edit->vscrollbar)->adjustment->value;
if((AGS_NOTE_EDIT_RESET_VSCROLLBAR & flags) != 0){
GtkWidget *widget;
GtkAdjustment *adjustment;
guint height;
widget = GTK_WIDGET(note_edit->drawing_area);
adjustment = GTK_RANGE(note_edit->vscrollbar)->adjustment;
if(note_edit->map_height > widget->allocation.height){
height = widget->allocation.height;
gtk_adjustment_set_upper(adjustment,
(gdouble) (note_edit->map_height - height));
gtk_adjustment_set_value(adjustment, 0.0);
}else{
height = note_edit->map_height;
gtk_adjustment_set_upper(adjustment, 0.0);
gtk_adjustment_set_value(adjustment, 0.0);
}
note_edit->height = height;
}
note_edit->y0 = ((guint) round((double) value)) % note_edit->control_height;
if(note_edit->y0 != 0){
note_edit->y0 = note_edit->control_height - note_edit->y0;
}
note_edit->y1 = (note_edit->height - note_edit->y0) % note_edit->control_height;
note_edit->nth_y = (guint) ceil(round((double) value) / (double)(note_edit->control_height));
note_edit->stop_y = note_edit->nth_y + (note_edit->height - note_edit->y0 - note_edit->y1) / note_edit->control_height;
/* refresh display */
if(GTK_WIDGET_VISIBLE(editor)){
ags_meter_paint(editor->meter);
cr = gdk_cairo_create(GTK_WIDGET(note_edit->drawing_area)->window);
cairo_push_group(cr);
ags_note_edit_draw_segment(note_edit, cr);
ags_note_edit_draw_notation(note_edit, cr);
if(editor->toolbar->selected_edit_mode == editor->toolbar->position){
ags_note_edit_draw_position(note_edit, cr);
}
cairo_pop_group_to_source(cr);
cairo_paint(cr);
}
}
}
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;
}
/**
* @param ddisp The diagram display object that a window is created for
* @param width Diagram widgth
* @param height Diagram Height
* @param title Window title
* @param use_mbar Flag to indicate whether to add a menubar to the window
*/
void
create_display_shell(DDisplay *ddisp,
int width, int height,
char *title, int use_mbar)
{
GtkWidget *table, *widget;
GtkWidget *status_hbox;
GtkWidget *root_vbox = NULL;
GtkWidget *zoom_hbox, *zoom_label;
int s_width, s_height;
if (app_is_interactive() && is_integrated_ui())
{
use_integrated_ui_for_display_shell(ddisp, title);
return;
}
ddisp->is_standalone_window = TRUE;
ddisp->container = NULL;
s_width = gdk_screen_width ();
s_height = gdk_screen_height ();
if (width > s_width)
width = s_width;
if (height > s_height)
height = s_height;
/* The toplevel shell */
ddisp->shell = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (ddisp->shell), title);
gtk_window_set_role (GTK_WINDOW (ddisp->shell), "diagram_window");
gtk_window_set_icon_name (GTK_WINDOW (ddisp->shell), "dia");
gtk_window_set_default_size(GTK_WINDOW (ddisp->shell), width, height);
/* set_icon_name needs registered theme icons, not always available: provide fallback */
if (!gtk_window_get_icon (GTK_WINDOW (ddisp->shell))) {
static GdkPixbuf *pixbuf = NULL;
if (!pixbuf)
pixbuf = gdk_pixbuf_new_from_inline(-1, dia_diagram_icon, FALSE, NULL);
if (pixbuf)
gtk_window_set_icon (GTK_WINDOW (ddisp->shell), pixbuf);
}
g_object_set_data (G_OBJECT (ddisp->shell), "user_data", (gpointer) ddisp);
_ddisplay_setup_events (ddisp, ddisp->shell);
/* following two not shared with integrated UI */
g_signal_connect (G_OBJECT (ddisp->shell), "delete_event",
G_CALLBACK (ddisplay_delete), ddisp);
g_signal_connect (G_OBJECT (ddisp->shell), "destroy",
G_CALLBACK (ddisplay_destroy), ddisp);
/* the table containing all widgets */
table = gtk_table_new (4, 3, FALSE);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 1);
gtk_table_set_col_spacing (GTK_TABLE (table), 1, 2);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 1);
gtk_table_set_row_spacing (GTK_TABLE (table), 1, 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 2);
if (use_mbar)
{
root_vbox = gtk_vbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (ddisp->shell), root_vbox);
gtk_box_pack_end (GTK_BOX (root_vbox), table, TRUE, TRUE, 0);
}
else
{
gtk_container_add (GTK_CONTAINER (ddisp->shell), table);
}
/* scrollbars, rulers, canvas, menu popup button */
if (!use_mbar) {
ddisp->origin = gtk_button_new();
#if GTK_CHECK_VERSION(2,18,0)
gtk_widget_set_can_focus (ddisp->origin, FALSE);
#else
GTK_WIDGET_UNSET_FLAGS(ddisp->origin, GTK_CAN_FOCUS);
#endif
widget = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
gtk_container_add(GTK_CONTAINER(ddisp->origin), widget);
gtk_widget_set_tooltip_text(widget, _("Diagram menu."));
gtk_widget_show(widget);
g_signal_connect(G_OBJECT(ddisp->origin), "button_press_event",
G_CALLBACK(origin_button_press), ddisp);
}
else {
ddisp->origin = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (ddisp->origin), GTK_SHADOW_OUT);
}
_ddisplay_setup_rulers (ddisp, ddisp->shell, table);
_ddisplay_setup_scrollbars (ddisp, table, width, height);
_ddisplay_setup_navigation (ddisp, table);
ddisp->canvas = create_canvas (ddisp);
/* pack all remaining widgets */
gtk_table_attach (GTK_TABLE (table), ddisp->origin, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), ddisp->canvas, 1, 2, 1, 2,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
/* TODO rob use per window accel */
ddisp->accel_group = menus_get_display_accels ();
gtk_window_add_accel_group(GTK_WINDOW(ddisp->shell), ddisp->accel_group);
if (use_mbar)
{
ddisp->menu_bar = menus_create_display_menubar (&ddisp->ui_manager, &ddisp->actions);
g_assert (ddisp->menu_bar);
gtk_box_pack_start (GTK_BOX (root_vbox), ddisp->menu_bar, FALSE, TRUE, 0);
}
/* the statusbars */
status_hbox = gtk_hbox_new (FALSE, 2);
/* Zoom status pseudo-optionmenu */
ddisp->zoom_status = create_zoom_widget(ddisp);
zoom_hbox = gtk_hbox_new(FALSE, 0);
zoom_label = gtk_label_new(_("Zoom"));
gtk_box_pack_start (GTK_BOX(zoom_hbox), zoom_label,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(zoom_hbox), ddisp->zoom_status,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (status_hbox), zoom_hbox, FALSE, FALSE, 0);
/* Grid on/off button */
ddisp->grid_status = dia_toggle_button_new_with_icons(dia_on_grid_icon,
dia_off_grid_icon);
g_signal_connect(G_OBJECT(ddisp->grid_status), "toggled",
G_CALLBACK (grid_toggle_snap), ddisp);
gtk_widget_set_tooltip_text(ddisp->grid_status,
_("Toggles snap-to-grid for this window."));
gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->grid_status,
FALSE, FALSE, 0);
ddisp->mainpoint_status = dia_toggle_button_new_with_icons(dia_mainpoints_on_icon,
dia_mainpoints_off_icon);
g_signal_connect(G_OBJECT(ddisp->mainpoint_status), "toggled",
G_CALLBACK (interface_toggle_mainpoint_magnetism), ddisp);
gtk_widget_set_tooltip_text(ddisp->mainpoint_status,
_("Toggles object snapping for this window."));
gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->mainpoint_status,
FALSE, FALSE, 0);
/* Statusbar */
ddisp->modified_status = gtk_statusbar_new ();
gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->modified_status,
TRUE, TRUE, 0);
gtk_table_attach (GTK_TABLE (table), status_hbox, 0, 3, 3, 4,
GTK_FILL, GTK_FILL, 0, 0);
display_rulers_show (ddisp);
gtk_widget_show (ddisp->zoom_status);
gtk_widget_show (zoom_hbox);
gtk_widget_show (zoom_label);
gtk_widget_show (ddisp->grid_status);
gtk_widget_show (ddisp->mainpoint_status);
gtk_widget_show (ddisp->modified_status);
gtk_widget_show (status_hbox);
gtk_widget_show (table);
if (use_mbar)
{
gtk_widget_show (ddisp->menu_bar);
gtk_widget_show (root_vbox);
}
gtk_widget_show (ddisp->shell);
/* before showing up, checking canvas's REAL size */
if (use_mbar && ddisp->hrule->allocation.width > width)
{
/* The menubar is not shrinkable, so the shell will have at least
* the menubar's width. If the diagram's requested width is smaller,
* the canvas will be enlarged to fit the place. In this case, we
* need to adjust the horizontal scrollbar according to the size
* that will be allocated, which the same as the hrule got.
*/
width = ddisp->hrule->allocation.width;
gtk_adjustment_set_upper (ddisp->hsbdata, width);
gtk_adjustment_set_page_increment (ddisp->hsbdata, (width - 1) / 4);
gtk_adjustment_set_page_size (ddisp->hsbdata, width - 1);
gtk_adjustment_changed (GTK_ADJUSTMENT(ddisp->hsbdata));
}
gtk_widget_show (ddisp->canvas);
/* set the focus to the canvas area */
gtk_widget_grab_focus (ddisp->canvas);
}
GtkWidget* create_prefs_window (void) {
GtkBuilder *builder;
GError *error = NULL;
GdkColor vol_meter_color_button_color;
gint *vol_meter_clrs;
gchar *vol_cmd,*uifile,*custcmd;
PrefsData *prefs_data;
uifile = get_ui_file("prefs.xml");
if (!uifile) {
report_error(_("Can't find preferences user interface file. Please insure PNMixer is installed correctly.\n"));
return NULL;
}
builder = gtk_builder_new();
if (!gtk_builder_add_from_file( builder, uifile, &error)) {
g_warning("%s",error->message);
report_error(error->message);
g_error_free(error);
g_free(uifile);
g_object_unref (G_OBJECT (builder));
return NULL;
}
g_free(uifile);
prefs_data = g_slice_new(PrefsData);
#define GO(name) prefs_data->name = GTK_WIDGET(gtk_builder_get_object(builder,#name))
GO(prefs_window);
GO(card_combo);
GO(chan_combo);
GO(vol_pos_label);
GO(vol_pos_combo);
GO(vol_meter_pos_label);
GO(vol_meter_pos_spin);
GO(vol_meter_color_label);
GO(vol_meter_color_button);
GO(custom_label);
GO(custom_entry);
GO(vol_text_check);
GO(draw_vol_check);
GO(icon_theme_combo);
GO(vol_control_entry);
GO(scroll_step_spin);
GO(middle_click_combo);
GO(enable_hotkeys_check);
GO(hotkey_spin);
GO(hotkey_dialog);
GO(hotkey_key_label);
GO(mute_hotkey_label);
GO(up_hotkey_label);
GO(down_hotkey_label);
#ifdef HAVE_LIBN
GO(enable_noti_check);
GO(hotkey_noti_check);
GO(mouse_noti_check);
GO(popup_noti_check);
GO(external_noti_check);
#endif
#undef GO
// vol text display
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON(prefs_data->vol_text_check),
g_key_file_get_boolean_with_default(keyFile,"PNMixer","DisplayTextVolume",FALSE));
gtk_combo_box_set_active
(GTK_COMBO_BOX (prefs_data->vol_pos_combo),
g_key_file_get_integer_with_default(keyFile,"PNMixer","TextVolumePosition",0));
// volume meter
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON(prefs_data->draw_vol_check),
g_key_file_get_boolean_with_default(keyFile,"PNMixer","DrawVolMeter",FALSE));
gtk_adjustment_set_upper
(GTK_ADJUSTMENT(gtk_builder_get_object(builder,"vol_meter_pos_adjustment")),
tray_icon_size()-10);
gtk_spin_button_set_value
(GTK_SPIN_BUTTON(prefs_data->vol_meter_pos_spin),
g_key_file_get_integer_with_default(keyFile,"PNMixer","VolMeterPos",0));
// load available icon themes into icon theme combo box. also sets active
load_icon_themes(prefs_data->icon_theme_combo,
GTK_LIST_STORE(gtk_builder_get_object(builder,"icon_theme_liststore")));
// set color button color
vol_meter_clrs = get_vol_meter_colors();
vol_meter_color_button_color.red = vol_meter_clrs[0];
vol_meter_color_button_color.green = vol_meter_clrs[1];
vol_meter_color_button_color.blue = vol_meter_clrs[2];
gtk_color_button_set_color(GTK_COLOR_BUTTON(prefs_data->vol_meter_color_button),
&vol_meter_color_button_color);
g_free(vol_meter_clrs);
// fill in card/channel combo boxes
fill_card_combo(prefs_data->card_combo,prefs_data->chan_combo);
// volume command
vol_cmd = get_vol_command();
if (vol_cmd) {
gtk_entry_set_text(GTK_ENTRY(prefs_data->vol_control_entry), vol_cmd);
g_free(vol_cmd);
}
// mouse scroll step
gtk_spin_button_set_value(GTK_SPIN_BUTTON(prefs_data->scroll_step_spin),
g_key_file_get_integer_with_default(keyFile,"PNMixer","MouseScrollStep",1));
// middle click
gtk_combo_box_set_active(GTK_COMBO_BOX(prefs_data->middle_click_combo),
g_key_file_get_integer_with_default(keyFile,"PNMixer","MiddleClickAction",0));
// custom command
gtk_entry_set_invisible_char(GTK_ENTRY(prefs_data->custom_entry), 8226);
custcmd = g_key_file_get_string(keyFile,"PNMixer","CustomCommand",NULL);
if (custcmd) {
gtk_entry_set_text(GTK_ENTRY(prefs_data->custom_entry),custcmd);
g_free(custcmd);
}
on_vol_text_toggle(GTK_TOGGLE_BUTTON(prefs_data->vol_text_check),
prefs_data);
on_draw_vol_toggle(GTK_TOGGLE_BUTTON(prefs_data->draw_vol_check),
prefs_data);
on_middle_changed(GTK_COMBO_BOX(prefs_data->middle_click_combo),
prefs_data);
// hotkeys
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON(prefs_data->enable_hotkeys_check),
g_key_file_get_boolean_with_default(keyFile,"PNMixer","EnableHotKeys",FALSE));
// hotkey step
gtk_spin_button_set_value(GTK_SPIN_BUTTON(prefs_data->hotkey_spin),
g_key_file_get_integer_with_default(keyFile,"PNMixer","HotkeyVolumeStep",1));
if (g_key_file_has_key(keyFile,"PNMixer","VolMuteKey",NULL))
set_label_for_keycode(prefs_data->mute_hotkey_label,
g_key_file_get_integer(keyFile,"PNMixer", "VolMuteKey", NULL),
g_key_file_get_integer_with_default(keyFile,"PNMixer", "VolMuteMods", 0));
if (g_key_file_has_key(keyFile,"PNMixer","VolUpKey",NULL))
set_label_for_keycode(prefs_data->up_hotkey_label,
g_key_file_get_integer(keyFile,"PNMixer", "VolUpKey", NULL),
g_key_file_get_integer_with_default(keyFile,"PNMixer", "VolUpMods", 0));
if (g_key_file_has_key(keyFile,"PNMixer","VolDownKey",NULL))
set_label_for_keycode(prefs_data->down_hotkey_label,
g_key_file_get_integer(keyFile,"PNMixer", "VolDownKey", NULL),
g_key_file_get_integer_with_default(keyFile,"PNMixer", "VolDownMods", 0));
gtk_notebook_append_page(GTK_NOTEBOOK(gtk_builder_get_object(builder,"notebook1")),
#ifdef HAVE_LIBN
GTK_WIDGET(gtk_builder_get_object(builder,"notification_vbox")),
#else
GTK_WIDGET(gtk_builder_get_object(builder,"no_notification_label")),
#endif
gtk_label_new("Notifications"));
#ifdef HAVE_LIBN
// notification checkboxes
set_notifications_booleans();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prefs_data->enable_noti_check),enable_noti);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prefs_data->hotkey_noti_check),hotkey_noti);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prefs_data->mouse_noti_check),mouse_noti);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prefs_data->popup_noti_check),popup_noti);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prefs_data->external_noti_check),external_noti);
on_notification_toggle(GTK_TOGGLE_BUTTON(prefs_data->enable_noti_check),prefs_data);
#endif
gtk_builder_connect_signals(builder, prefs_data);
g_object_unref (G_OBJECT (builder));
return prefs_data->prefs_window;
}
//initializations and simple modifications for the things that will be drawn
void ClientViewer::initClientViewer(int numberOfRobots, int myTeam, int _drawFactor) {
#ifdef DEBUG
string tmp=helper::logDirectory + helper::clientViewerDebugLogName;
debug.open(tmp.c_str(), ios::out);
debug << "Starting the Client Viewer!" << endl;
#endif
g_type_init();
//load the builder file
gtk_builder_add_from_file(builder, builderPath.c_str(), NULL);
GtkWidget *mainWindow = GTK_WIDGET(gtk_builder_get_object(builder, "window"));
GtkToggleToolButton *info = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builder, "Info"));
GtkToolButton *zoomIn = GTK_TOOL_BUTTON(gtk_builder_get_object(builder, "ZoomIn"));
GtkToolButton *zoomOut = GTK_TOOL_BUTTON(gtk_builder_get_object(builder, "ZoomOut"));
GtkWidget *about = GTK_WIDGET(gtk_builder_get_object(builder, "About"));
GtkWidget *infoWindow = GTK_WIDGET(gtk_builder_get_object(builder, "infoWindow"));
GtkSpinButton *robotId = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "robotId"));
GdkColor color;
//drawing related variables
drawFactor = new int();
*drawFactor = _drawFactor;
int imageWidth = (VIEWDISTANCE+ROBOTDIAMETER) * (*drawFactor) * 2, imageHeight = (VIEWDISTANCE + ROBOTDIAMETER) * (*drawFactor) * 2;
#ifdef DEBUG
debug << "imageWidth is " << imageWidth << " and the imageHeight is " << imageHeight << endl;
#endif
drawingArea = GTK_DRAWING_AREA(gtk_builder_get_object(builder, "drawingArea"));
gtk_widget_set_size_request(GTK_WIDGET(drawingArea), imageWidth, imageHeight);
gtk_window_resize(GTK_WINDOW(mainWindow), imageWidth, imageHeight);
//set the upper value for the spin button
gtk_adjustment_set_upper(GTK_ADJUSTMENT(gtk_builder_get_object(builder, "robotIdAdjustment")), numberOfRobots - 1);
gtk_adjustment_set_value(GTK_ADJUSTMENT(gtk_builder_get_object(builder, "robotIdAdjustment")), -1);
//keep the info window floating on top of the main window
gtk_window_set_keep_above(GTK_WINDOW(infoWindow), true);
//change the color of the main window's background to black
gdk_color_parse("black", &color);
gtk_widget_modify_bg(GTK_WIDGET(mainWindow), GTK_STATE_NORMAL, &color);
//change the color of the info window text
gdk_color_parse("white", &color);
gtk_widget_modify_fg(GTK_WIDGET(gtk_builder_get_object(builder, "labSpeed")), GTK_STATE_NORMAL, &color);
gtk_widget_modify_fg(GTK_WIDGET(gtk_builder_get_object(builder, "labAngle")), GTK_STATE_NORMAL, &color);
gtk_widget_modify_fg(GTK_WIDGET(gtk_builder_get_object(builder, "labFrames")), GTK_STATE_NORMAL, &color);
gtk_widget_modify_fg(GTK_WIDGET(gtk_builder_get_object(builder, "labPuck")), GTK_STATE_NORMAL, &color);
gtk_widget_modify_fg(GTK_WIDGET(gtk_builder_get_object(builder, "labHome")), GTK_STATE_NORMAL, &color);
gtk_widget_modify_fg(GTK_WIDGET(gtk_builder_get_object(builder, "labDestination")), GTK_STATE_NORMAL, &color);
gtk_widget_modify_bg(GTK_WIDGET(drawingArea), GTK_STATE_NORMAL, &color);
g_signal_connect(robotId, "value-changed", G_CALLBACK(onRobotIdChanged), (gpointer) & viewedRobot);
g_signal_connect(info, "toggled", G_CALLBACK(onWindowToggled), (gpointer) infoWindow);
g_signal_connect(about, "clicked", G_CALLBACK(onAboutClicked), (gpointer) mainWindow);
g_signal_connect(zoomIn, "clicked", G_CALLBACK(onZoomInClicked), (gpointer)(new passToZoom( drawFactor, mainWindow, drawingArea, zoomIn, zoomOut)));
g_signal_connect(zoomOut, "clicked", G_CALLBACK(onZoomOutClicked), (gpointer)(new passToZoom(drawFactor, mainWindow, drawingArea, zoomIn, zoomOut)));
g_signal_connect(gtk_builder_get_object(builder, "Exit"), "clicked", G_CALLBACK(quitButtonDestroy), (gpointer)new passToQuit(&viewedRobot, mainWindow));
g_signal_connect(mainWindow, "destroy", G_CALLBACK(mainDestroy), (gpointer) &viewedRobot);
g_signal_connect(mainWindow, "delete-event", G_CALLBACK(mainDeleteEvent), (gpointer) &viewedRobot);
g_signal_connect(infoWindow, "destroy", G_CALLBACK(infoDestroy), (gpointer) info);
g_signal_connect(infoWindow, "delete-event", G_CALLBACK(infoDeleteEvent), (gpointer) info);
g_signal_connect(drawingArea, "expose-event", G_CALLBACK(drawingAreaExpose), (gpointer)(
new passToDrawingAreaExpose(myTeam, numberOfRobots, drawFactor, &draw, &ownRobotDraw, info, builder)));
gtk_widget_show_all(mainWindow);
}
void texture_select_callback(GObject* obj, gpointer user_data) {
GtkTreeView* param_tree = GTK_TREE_VIEW(gtk_builder_get_object(builder, "selected_texture_treeview"));
GtkTreeStore* param_store = GTK_TREE_STORE(gtk_tree_view_get_model(param_tree));
GtkTreeView* image_tree = GTK_TREE_VIEW(gtk_builder_get_object(builder, "selected_texture_images"));
GtkTreeStore* image_store = GTK_TREE_STORE(gtk_tree_view_get_model(image_tree));
if (!param_store)
return;
if (!image_store)
return;
gtk_tree_store_clear(image_store);
gtk_tree_store_clear(param_store);
GtkTreePath* path;
GtkSpinButton* layer_spinbutton = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "layer_spinbutton"));
gtk_tree_view_get_cursor(GTK_TREE_VIEW(obj), &path, NULL);
if (!path) {
gtk_adjustment_set_upper(gtk_spin_button_get_adjustment(layer_spinbutton), 0);
return;
}
//Initialize params
size_t tex_index = gtk_tree_path_get_indices(path)[0];
inspect_texture_t* tex = get_inspect_tex_vec(inspector->textures, tex_index);
if (!tex) return;
gtk_adjustment_set_upper(gtk_spin_button_get_adjustment(layer_spinbutton), tex->layer_count-1);
inspect_gl_tex_params_t params = tex->params;
GtkTreeIter row;
#define VAL(name, val) gtk_tree_store_append(param_store, &row, NULL);\
gtk_tree_store_set(param_store, &row, 0, (name), 1, (val), -1);
if (tex->type) {
VAL("Type", static_format("%s", get_enum_str("TextureTarget", tex->type)));
VAL("Depth Stencil Mode", static_format("%s", get_enum_str(NULL, params.depth_stencil_mode)));
VAL("Min Filter", static_format("%s", get_enum_str("TextureMinFilter", params.min_filter)));
VAL("Mag Filter", static_format("%s", get_enum_str("TextureMagFilter", params.mag_filter)));
VAL("Min LOD", static_format("%s", format_float(params.min_lod)));
VAL("Max LOD", static_format("%s", format_float(params.max_lod)));
VAL("LOD bias", static_format("%s", format_float(params.lod_bias)));
VAL("Base Level", static_format("%d", params.base_level));
VAL("Max Level", static_format("%d", params.max_level));
VAL("Swizzle", static_format("[%s, %s, %s, %s]",
get_enum_str(NULL, params.swizzle[0]),
get_enum_str(NULL, params.swizzle[1]),
get_enum_str(NULL, params.swizzle[2]),
get_enum_str(NULL, params.swizzle[3])));
VAL("Wrap S", static_format("%s", get_enum_str("TextureWrapMode", params.wrap[0])));
VAL("Wrap T", static_format("%s", get_enum_str("TextureWrapMode", params.wrap[0])));
VAL("Wrap R", static_format("%s", get_enum_str("TextureWrapMode", params.wrap[0])));
VAL("Border Color", static_format("[%s, %s, %s, %s]",
format_float(params.border_color[0]),
format_float(params.border_color[1]),
format_float(params.border_color[2]),
format_float(params.border_color[3])));
VAL("Compare Mode", static_format("%s", get_enum_str(NULL, params.compare_mode)));
VAL("Compare Func", static_format("%s", get_enum_str("DepthFunction", params.compare_func)));
VAL("View Min Level", static_format("%d", params.view_min_level));
VAL("View Num Levels", static_format("%u", params.view_num_levels));
VAL("View Min Layer", static_format("%d", params.view_min_layer));
VAL("View Num Layers", static_format("%u", params.view_num_layers));
VAL("Immutable levels", static_format("%u", params.immutable_levels));
VAL("Image Format Compat Type", static_format("%s", get_enum_str(NULL, params.image_format_compatibility_type)));
VAL("Immutable Format", static_format("%s", get_enum_str(NULL, params.immutable_format)));
}
if (tex->mipmaps) {
VAL("Width", static_format("%zu", tex->width));
VAL("Height", static_format("%zu", tex->height));
VAL("Depth", static_format("%zu", tex->depth));
VAL("Mipmap Count", static_format("%zu", tex->mipmap_count));
VAL("Layer Count", static_format("%zu", tex->layer_count));
#undef VAL
GtkSpinButton* layer_button = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "layer_spinbutton"));
uint32_t layer = gtk_spin_button_get_value(GTK_SPIN_BUTTON(layer_button));
GtkComboBox* face_combobox = GTK_COMBO_BOX(gtk_builder_get_object(builder, "face_combobox"));
gint face = gtk_combo_box_get_active(GTK_COMBO_BOX(face_combobox));
//Initialize images
size_t w = tex->width;
size_t h = tex->height;
for (size_t level = 0; level < tex->mipmap_count; level++) {
inspect_image_t* img = inspect_get_tex_mipmap(tex, level, layer, face);
if (img->has_data) {
uint32_t* data = (uint32_t*)malloc(w*h*4);
inspect_get_image_data(img, data);
GtkTreeIter row;
gtk_tree_store_append(image_store, &row, NULL);
GdkPixbuf* pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, w, h);
uint32_t* dest = (uint32_t*)gdk_pixbuf_get_pixels(pixbuf);
for (size_t y = 0; y < h; y++) {
for (size_t x = 0; x < w; x++) {
dest[(h-1-y)*w+x] = data[y*w+x];
}
}
gtk_tree_store_set(image_store, &row, 0, static_format("%u", level), 1, pixbuf, -1);
g_object_unref(pixbuf);
free(data);
}
w /= 2;
h /= 2;
}
}
}
int
main( int argc,
char **argv )
{
GtkBuilder *builder;
GError *error = NULL;
int ret;
/* MagickWand Init */
MagickWandGenesis();
camera_params.wand_data.display_magick_wand=NewMagickWand();
camera_params.wand_data.processed_magick_wand=NewMagickWand();
camera_params.wand_data.raw_magick_wand=NewMagickWand();
camera_params.wand_data.raw_directory=NULL;
camera_params.wand_data.processed_directory=NULL;
camera_params.wand_data.processed_img_ok = 0;
camera_params.wand_data.raw_img_ok = 0;
pthread_mutex_init(&camera_params.wand_data.processed_img_mutex, NULL);
pthread_mutex_init(&camera_params.wand_data.raw_img_mutex, NULL);
pthread_mutex_init(&camera_params.wand_data.display_img_mutex, NULL);
pthread_mutex_init(&camera_params.wand_data.background_img_mutex, NULL);
camera_params.list_file = fopen (LIST_FILENAME, "w");
if (camera_params.list_file == NULL)
g_print("cannot open %s\n",LIST_FILENAME);
else
{
fprintf(camera_params.list_file,"#image_number\timage_acq_number\ttime\tmean\tmean_soft\tmean_soft_roi1\tmean_soft_roi2\n");
}
/* We are using a threaded program we must say it to gtk */
if( ! g_thread_supported() )
g_thread_init(NULL);
gdk_threads_init();
/* Obtain gtk's global lock */
gdk_threads_enter();
/* Init GTK+ */
gtk_init( &argc, &argv );
/* Create new GtkBuilder object */
builder = gtk_builder_new();
/* Load UI from file. If error occurs, report it and quit application.
* Replace "tut.glade" with your saved project. */
if( ! gtk_builder_add_from_file( builder, "camera_interface.glade", &error ) )
{
g_warning( "%s", error->message );
g_free( error );
return( 1 );
}
/* Allocate data structure */
camera_params.objects = g_slice_new( gui_objects_t );
/* Get objects from UI */
#define GW( name ) CH_GET_WIDGET( builder, name, data )
GW( main_window );
GW( main_status_bar );
GW( camera_text );
GW( image_number );
GW( raw_image );
GW( processed_image );
GW( trig_mult );
GW( trig_single );
GW( trig_cont );
GW( freerun_trig );
GW( ext1_trig );
GW( ext2_trig );
GW( framerate_trig );
GW( directorychooserdialog );
GW( imagesavedialog );
GW( listsavedialog );
GW( no_image_dialog );
GW( ROI_confirm_dialog );
GW( ROI_confirm_dialog_text );
GW( stats_treeview );
GW( acq_toggle );
GW( mean_bar );
GW( soft_rotate_image );
GW( soft_magn_x2 );
GW( soft_magn_x4 );
GW( soft_magn_x8 );
GW( soft_cut_img );
GW( soft_image_text );
GW( soft_display_mean_roi1 );
GW( soft_compute_mean_roi1 );
GW( soft_display_mean_roi2 );
GW( soft_compute_mean_roi2 );
GW( soft_background_info_text );
GW( soft_background_button );
GW( processed_mean_bar );
GW( processed_mean_roi1 );
GW( processed_mean_roi1_bar );
GW( processed_mean_roi2 );
GW( processed_mean_roi2_bar );
GW( soft_dont_update_current );
GW( soft_timing_text );
GW( ROI_height );
GW( ROI_width );
GW( ROI_start_x );
GW( ROI_start_y );
GW( Exp_gain );
GW( Exp_time );
GW( raw_autosave );
GW( raw_text );
GW( list_text );
GW( camera_choose_win );
GW( camera_list_combo );
GW( trig_framerate );
GW( net_expander );
#undef GW
/* Get adjustments objects from UI */
#define GA( name ) CH_GET_ADJUSTMENT( builder, name, data )
GA( Exp_adj_gain );
GA( Exp_adj_time );
GA( ROI_adjust_x );
GA( ROI_adjust_y );
GA( ROI_adjust_width );
GA( ROI_adjust_height );
GA( Bin_X_adj );
GA( Bin_Y_adj );
GA( Bytes_per_sec_adj );
GA( Trig_nbframes_adj);
GA( Trig_framerate_adj);
GA( min_meanbar );
GA( max_meanbar );
GA( soft_angle_adj );
GA( soft_level_min_adj );
GA( soft_level_max_adj );
GA( ROI_soft_adjust_width );
GA( ROI_soft_adjust_height );
GA( ROI_soft_adjust_x );
GA( ROI_soft_adjust_y );
GA( ROI_soft_mean_adjust_x1 );
GA( ROI_soft_mean_adjust_width1 );
GA( ROI_soft_mean_adjust_y1 );
GA( ROI_soft_mean_adjust_height1 );
GA( ROI_soft_mean_adjust_x2 );
GA( ROI_soft_mean_adjust_width2 );
GA( ROI_soft_mean_adjust_y2 );
GA( ROI_soft_mean_adjust_height2 );
GA( processed_mean_min_adj );
GA( processed_mean_max_adj );
GA( processed_mean_roi1_min_adj );
GA( processed_mean_roi1_max_adj );
GA( processed_mean_roi2_min_adj );
GA( processed_mean_roi2_max_adj );
#undef GA
#define GL( name ) CH_GET_LIST_STORE( builder, name, data )
GL( statistics_list );
GL( camera_list );
#undef GL
/* Connect signals */
gtk_builder_connect_signals( builder, NULL );
/* Destroy builder, since we don't need it anymore */
g_object_unref( G_OBJECT( builder ) );
/* Show window. All other widgets are automatically shown by GtkBuilder */
gtk_widget_show( camera_params.objects->main_window );
//Hide some of the widgets
gtk_widget_hide_all(camera_params.objects->processed_mean_roi1);
gtk_widget_hide_all(camera_params.objects->processed_mean_roi2);
//Good values, the images are stored on 16 bits
gtk_adjustment_set_upper(camera_params.objects->processed_mean_min_adj,1<<16);
gtk_adjustment_set_upper(camera_params.objects->processed_mean_max_adj,1<<16);
gtk_adjustment_set_value(camera_params.objects->processed_mean_max_adj,1<<16);
gtk_adjustment_set_upper(camera_params.objects->processed_mean_roi1_min_adj,1<<16);
gtk_adjustment_set_upper(camera_params.objects->processed_mean_roi1_max_adj,1<<16);
gtk_adjustment_set_value(camera_params.objects->processed_mean_roi1_max_adj,1<<16);
gtk_adjustment_set_upper(camera_params.objects->processed_mean_roi2_min_adj,1<<16);
gtk_adjustment_set_upper(camera_params.objects->processed_mean_roi2_max_adj,1<<16);
gtk_adjustment_set_value(camera_params.objects->processed_mean_roi2_max_adj,1<<16);
/* Start the camera thread */
ret=pthread_create(&(camera_params.camera_thread), NULL, camera_thread_func, &camera_params);
if(ret){
g_warning( "Thread creation error %d", ret );
return( 1 );
}
gchar *msg;
if (camera_params.list_file == NULL)
{
msg = g_strdup_printf ("Problem openning %s for writing",LIST_FILENAME);
}
else
{
msg = g_strdup_printf ("The list will be continuously saved in %s",LIST_FILENAME);
}
gtk_text_buffer_set_text(gtk_text_view_get_buffer (GTK_TEXT_VIEW (camera_params.objects->list_text)),msg,-1);
g_free (msg);
/* Start main loop */
gtk_main();
/* Release gtk's global lock */
gdk_threads_leave();
pthread_join(camera_params.camera_thread, NULL);
/* We derease the pixbuf reference counter */
if(camera_params.raw_image_pixbuff!=NULL)
g_object_unref(camera_params.raw_image_pixbuff);
/* Free any allocated data */
g_slice_free( gui_objects_t, camera_params.objects );
pthread_mutex_destroy(&camera_params.wand_data.processed_img_mutex);
pthread_mutex_destroy(&camera_params.wand_data.raw_img_mutex);
pthread_mutex_destroy(&camera_params.wand_data.display_img_mutex);
pthread_mutex_destroy(&camera_params.wand_data.background_img_mutex);
if(camera_params.wand_data.raw_directory)
free(camera_params.wand_data.raw_directory);
if(camera_params.wand_data.processed_directory)
free(camera_params.wand_data.processed_directory);
if(camera_params.background_set)
DestroyMagickWand(camera_params.wand_data.background_wand);
if(camera_params.wand_data.saving_wand)
DestroyMagickWand(camera_params.wand_data.saving_wand);
DestroyMagickWand(camera_params.wand_data.raw_magick_wand);
DestroyMagickWand(camera_params.wand_data.processed_magick_wand);
DestroyMagickWand(camera_params.wand_data.display_magick_wand);
MagickWandTerminus();
if (camera_params.list_file != NULL)
fclose(camera_params.list_file);
return( 0 );
}
