static void
colorsel_water_init (ColorselWater *water)
{
GtkWidget *hbox;
GtkWidget *area;
GtkWidget *frame;
GtkObject *adj;
GtkWidget *scale;
water->pressure_adjust = 1.0;
hbox = gtk_hbox_new (FALSE, 2);
gtk_box_pack_start (GTK_BOX (water), hbox, TRUE, TRUE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
area = gtk_drawing_area_new ();
gtk_container_add (GTK_CONTAINER (frame), area);
g_signal_connect (area, "expose-event",
G_CALLBACK (select_area_expose),
NULL);
/* Event signals */
g_signal_connect (area, "motion-notify-event",
G_CALLBACK (motion_notify_event),
water);
g_signal_connect (area, "button-press-event",
G_CALLBACK (button_press_event),
water);
g_signal_connect (area, "proximity-out-event",
G_CALLBACK (proximity_out_event),
water);
gtk_widget_add_events (area,
GDK_LEAVE_NOTIFY_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_KEY_PRESS_MASK |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_PROXIMITY_OUT_MASK);
/* The following call enables tracking and processing of extension
* events for the drawing area
*/
gtk_widget_set_extension_events (area, GDK_EXTENSION_EVENTS_ALL);
gtk_widget_grab_focus (area);
adj = gtk_adjustment_new (200.0 - water->pressure_adjust * 100.0,
0.0, 200.0, 1.0, 1.0, 0.0);
g_signal_connect (adj, "value-changed",
G_CALLBACK (pressure_adjust_update),
water);
scale = gtk_vscale_new (GTK_ADJUSTMENT (adj));
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gimp_help_set_help_data (scale, _("Pressure"), NULL);
gtk_box_pack_start (GTK_BOX (hbox), scale, FALSE, FALSE, 0);
gtk_widget_show_all (hbox);
}
GtkWidget *voronoi_dialog_new (gpointer data) {
GtkWidget *vbox, *vbox2, *vbox3, *guide_box, *hbox, *hbox1, *hbox2, *frame, *frame2, *button, *wdg, *check_box, *lblmax, *lblwidth, *button_uniform, *preview_box, *scale;
GtkObject *adj;
GSList *group = NULL, *group1 = NULL, *group2 = NULL, *group3 = NULL;
voronoi_struct *vs;
voronoi_dialog_struct *vds;
hf_wrapper_struct *hfw;
hfw = (hf_wrapper_struct *) * (hf_wrapper_struct **) data;
vs = hfw->hf_options->img->voronoi;
vds = hfw->hf_options->img->voronoi_dialog;
frame = options_frame_new("Cracks network");
vbox = gtk_vbox_new(FALSE,DEF_PAD);
gtk_widget_show(GTK_WIDGET(vbox));
hbox = gtk_hbox_new(FALSE,DEF_PAD);
gtk_widget_show(GTK_WIDGET(hbox));
define_label_in_box("Average cell size", hbox, FALSE,TRUE, DEF_PAD);
vds->adj_cell_size = gtk_adjustment_new (
vs->cell_size,0.0, 50.0, 0.1, 0.1, 0.0);
define_scale_in_box(vds->adj_cell_size,hbox,1,DEF_PAD);
gtk_signal_connect (GTK_OBJECT (vds->adj_cell_size), "value_changed", GTK_SIGNAL_FUNC (gdouble_adj_callb), (gpointer) &vs->cell_size);
gtk_signal_connect (GTK_OBJECT (vds->adj_cell_size), "value_changed", GTK_SIGNAL_FUNC (gboolean_set_false), (gpointer) &hfw->if_calculated);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox),
seed_dialog_new(data, vs->seed, change_voronoi_seed),
TRUE, TRUE, 0);
// ******** Distribution of cells
// Box for radio buttons
vbox2 = gtk_vbox_new(FALSE,0);
gtk_widget_show(GTK_WIDGET(vbox2));
frame2 = define_frame_with_hiding_arrows ("Cell distribution", vbox2, hfw->hf_options->tools_window, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), frame2, TRUE, TRUE, 0);
// We need a scale for the REGULAR option, for controlling the perturbation
hbox = gtk_hbox_new(FALSE,DEF_PAD);
gtk_widget_show(GTK_WIDGET(hbox));
define_label_in_box("Random variation", hbox, FALSE,TRUE, DEF_PAD);
vds->adj_random_variation = gtk_adjustment_new (
vs->random_variation,0.0, 100.0, 1, 1, 0.0);
wdg = define_scale_in_box(vds->adj_random_variation,hbox,0,DEF_PAD);
gtk_signal_connect (GTK_OBJECT (vds->adj_random_variation), "value_changed", GTK_SIGNAL_FUNC (gint_adj_callb), (gpointer) &vs->random_variation);
gtk_signal_connect (GTK_OBJECT (vds->adj_random_variation), "value_changed", GTK_SIGNAL_FUNC (gboolean_set_false), (gpointer) &hfw->if_calculated);
// We need a row of buttons for controlling the scale (multiple or not)
hbox1 = gtk_hbox_new(FALSE,DEF_PAD);
define_label_in_box("Scale", hbox1, FALSE,TRUE, DEF_PAD);
gtk_widget_show(GTK_WIDGET(hbox1));
define_radio_button_in_box_with_data (hbox1, &group1, "1X", set_scale_1x, &vs->scale, (vs->scale==SCALE_1X)) ;
define_radio_button_in_box_with_data (hbox1, &group1, "1X+2X", set_scale_1x_2x, &vs->scale, (vs->scale==SCALE_1X_2X)) ;
define_radio_button_in_box_with_data (hbox1, &group1, "1X+2X+4X", set_scale_1x_2x_4x, &vs->scale, (vs->scale==SCALE_1X_2X_4X)) ;
button =
define_radio_button_in_box_with_data (vbox2, &group, "Uniform / random",
set_uniform_distrib, &vs->distribution_type,
(vs->distribution_type==UNIFORM)) ;
gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) hide_if_true, (gpointer) hbox);
gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) show_if_true, (gpointer) hbox1);
button =
define_radio_button_in_box_with_data (vbox2, &group, "Centered / random",
set_centered_distrib, &vs->distribution_type,
(vs->distribution_type==CENTERED)) ;
gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) hide_if_true, (gpointer) hbox);
gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) show_if_true, (gpointer) hbox1);
button =
define_radio_button_in_box_with_data (vbox2, &group, "Regular / perturbated",
set_regular_distrib, &vs->distribution_type,
(vs->distribution_type==REGULAR)) ;
gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) show_if_true, (gpointer) hbox);
gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) hide_if_true, (gpointer) hbox1);
// At the end, We add the random variation scale for REGULAR
// and the radio buttons for the multiple scale control
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), hbox1, FALSE, FALSE, 0);
if (vs->distribution_type!=REGULAR)
gtk_widget_hide(GTK_WIDGET(hbox));
else
gtk_widget_hide(GTK_WIDGET(hbox1));
/*****************************************************/
// Now specify how the current HF should be used
vbox2 = gtk_vbox_new(FALSE,0);
gtk_widget_show(GTK_WIDGET(vbox2));
frame2 = define_frame_with_hiding_arrows ("Use of current height field", vbox2, hfw->hf_options->tools_window, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), frame2, FALSE, FALSE, 0.5*DEF_PAD);
// Vbox3: "USE AS GUIDE" dialog (for adding noise)
guide_box = gtk_vbox_new(FALSE,DEF_PAD);
gtk_widget_show(GTK_WIDGET(guide_box));
check_box = define_check_button_in_box ("Gener noise anyway?", guide_box, 0, 0, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_box),vs->gener_noise);
gtk_signal_connect (GTK_OBJECT(check_box), "toggled",
GTK_SIGNAL_FUNC(toggle_check_button_callb), (gpointer) &vs->gener_noise);
// Preview box
preview_box = gtk_hbox_new(FALSE,DEF_PAD);
gtk_widget_show(GTK_WIDGET(preview_box));
vds->noise_preview =
view_struct_new(NOISE_PREVIEW_SIZE,NOISE_PREVIEW_SIZE,(gpointer) compute_noise_preview,(gpointer) hfw->hf_options->img);
gtk_box_pack_start(GTK_BOX(preview_box), vds->noise_preview->area, TRUE, TRUE, DEF_PAD *0.5);
vbox3 = seed_dialog_new_lbl(hfw->hf_options->img, vs->noise_opt->seed, change_noise_seed, FALSE, VERTICAL_BOX );
adj = gtk_adjustment_new (0, -4, 4, 1, 1, 0.1);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adj));
gtk_widget_set_usize(scale,75,0);
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_box_pack_start (GTK_BOX (vbox3), scale, TRUE, TRUE, DEF_PAD*0.5);
gtk_widget_show (scale);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC(gint_adj_callb), &vs->noise_opt->roughness);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC(draw_area_callb), vds->noise_preview);
gtk_box_pack_start(GTK_BOX(preview_box), vbox3, TRUE, TRUE, DEF_PAD*0.5);
gtk_box_pack_start(GTK_BOX(guide_box), preview_box, FALSE, FALSE, 0.5*DEF_PAD);
gtk_signal_connect (GTK_OBJECT (check_box), "toggled",
(GtkSignalFunc) show_if_true, (gpointer) preview_box);
if (vs->gener_noise==FALSE)
gtk_widget_hide(GTK_WIDGET(preview_box));
// Scale for the noise level
hbox2 = gtk_hbox_new(FALSE,DEF_PAD);
gtk_widget_show(GTK_WIDGET(hbox2));
define_label_in_box("Noise level", hbox2, FALSE,TRUE, DEF_PAD);
vds->adj_noise_level = gtk_adjustment_new (
vs->noise_level,0.0, 100.0, 1, 1, 0.0);
wdg = define_scale_in_box(vds->adj_noise_level,hbox2,0,DEF_PAD);
gtk_signal_connect (GTK_OBJECT (vds->adj_noise_level), "value_changed", GTK_SIGNAL_FUNC (gint_adj_callb), (gpointer) &vs->noise_level);
gtk_signal_connect (GTK_OBJECT (vds->adj_noise_level), "value_changed", GTK_SIGNAL_FUNC (gboolean_set_false), (gpointer) &hfw->if_calculated);
gtk_signal_connect (GTK_OBJECT (check_box), "toggled",
(GtkSignalFunc) show_if_true, (gpointer) hbox2);
// hbox for NOISE vs GUIDE radio buttons
hbox = gtk_hbox_new(FALSE,0);
gtk_widget_show(GTK_WIDGET(hbox));
button = define_radio_button_in_box_with_data (hbox, &group2, "As noise",
set_use_as_noise, &vs->hf_use, (vs->hf_use==USE_AS_NOISE)) ;
gtk_signal_connect (GTK_OBJECT (button), "toggled",
(GtkSignalFunc) hide_if_true, (gpointer) check_box);
// Always show the noise scale in that case
gtk_signal_connect_object(GTK_OBJECT(button), "toggled",
GTK_SIGNAL_FUNC(gtk_widget_show), (gpointer) wdg);
button = define_radio_button_in_box_with_data (hbox, &group2, "As guide",
set_use_as_guide, &vs->hf_use, (vs->hf_use==USE_AS_GUIDE)) ;
gtk_signal_connect (GTK_OBJECT (button), "toggled",
(GtkSignalFunc) show_if_true, (gpointer) guide_box);
if (vs->hf_use==USE_AS_NOISE)
gtk_widget_hide(GTK_WIDGET(guide_box));
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox2), guide_box, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
/*********************** Crack width **************************/
vbox2 = gtk_vbox_new(FALSE,0);
gtk_widget_show(GTK_WIDGET(vbox2));
frame2 = define_frame_with_hiding_arrows ("Crack width", vbox2, hfw->hf_options->tools_window, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), frame2, FALSE, FALSE, 0.5*DEF_PAD);
hbox = gtk_hbox_new(FALSE,DEF_PAD);
gtk_widget_show(GTK_WIDGET(hbox));
button_uniform = define_radio_button_in_box_with_data (hbox, &group3, "Uniform", set_fixed_width, &vs->crack_width_type, vs->crack_width_type==FIXED_WIDTH) ;
button = define_radio_button_in_box_with_data (hbox, &group3, "From distance",set_from_distance, &vs->crack_width_type, vs->crack_width_type==FROM_DISTANCE) ;
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
// Width: in pixels for "Uniform", relative for "Varies with distance"
hbox = gtk_hbox_new(FALSE,DEF_PAD);
gtk_widget_show(GTK_WIDGET(hbox));
define_label_in_box("Min", hbox, FALSE,TRUE, DEF_PAD);
vds->adj_min_width = gtk_adjustment_new (
vs->min_width,0.0, 10.0, 1, 1, 0.0);
wdg = define_scale_in_box(vds->adj_min_width,hbox,0,DEF_PAD);
gtk_signal_connect (GTK_OBJECT (vds->adj_min_width), "value_changed", GTK_SIGNAL_FUNC (gint_adj_callb), (gpointer) &vs->min_width);
gtk_signal_connect (GTK_OBJECT (vds->adj_min_width), "value_changed", GTK_SIGNAL_FUNC (gboolean_set_false), (gpointer) &hfw->if_calculated);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button_uniform), "toggled",
(GtkSignalFunc) hide_if_true, (gpointer) hbox);
if (vs->crack_width_type==FIXED_WIDTH)
gtk_widget_hide(GTK_WIDGET(hbox));
hbox = gtk_hbox_new(FALSE,DEF_PAD);
gtk_widget_show(GTK_WIDGET(hbox));
lblmax = define_label_in_box("Max", hbox, FALSE,TRUE, DEF_PAD);
lblwidth = define_label_in_box("Width", hbox, FALSE,TRUE, DEF_PAD);
vds->adj_max_width = gtk_adjustment_new (
vs->max_width,0.0, 10.0, 1, 1, 0.0);
wdg = define_scale_in_box(vds->adj_max_width,hbox,0,DEF_PAD);
gtk_signal_connect (GTK_OBJECT (vds->adj_max_width), "value_changed", GTK_SIGNAL_FUNC (gint_adj_callb), (gpointer) &vs->max_width);
gtk_signal_connect (GTK_OBJECT (vds->adj_max_width), "value_changed", GTK_SIGNAL_FUNC (gboolean_set_false), (gpointer) &hfw->if_calculated);
// Consistency controls (min should be <= max)
gtk_signal_connect (GTK_OBJECT (vds->adj_min_width), "value_changed", GTK_SIGNAL_FUNC (check_max_width), (gpointer) hfw->hf_options->img);
gtk_signal_connect (GTK_OBJECT (vds->adj_max_width), "value_changed", GTK_SIGNAL_FUNC (check_min_width), (gpointer) hfw->hf_options->img);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button_uniform), "toggled",
(GtkSignalFunc) hide_if_true, (gpointer) lblmax);
gtk_signal_connect (GTK_OBJECT (button_uniform), "toggled",
(GtkSignalFunc) show_if_true, (gpointer) lblwidth);
if (vs->crack_width_type==FIXED_WIDTH)
gtk_widget_hide(GTK_WIDGET(lblmax));
button = gtk_button_new_with_label (_("Apply"));
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) apply_voronoi_callb, data);
gtk_widget_show(button);
gtk_box_pack_start(GTK_BOX(vbox), align_widget(button,0.5,0.5), FALSE, FALSE, DEF_PAD);
/************************ Edge level control ************************/
hbox = gtk_hbox_new(FALSE,DEF_PAD);
gtk_widget_show(GTK_WIDGET(hbox));
define_label_in_box("Edge raising", hbox, FALSE,TRUE, DEF_PAD);
vds->adj_edges_level = gtk_adjustment_new (
vs->edges_level,0.0, 100.0, 1, 1, 0.0);
vds->wdg_edges_level = define_scale_in_box(vds->adj_edges_level,hbox,0,DEF_PAD);
gtk_signal_connect (GTK_OBJECT (vds->adj_edges_level), "value_changed", GTK_SIGNAL_FUNC (gint_adj_callb), (gpointer) &vs->edges_level);
gtk_signal_connect (GTK_OBJECT (vds->adj_edges_level), "value_changed", GTK_SIGNAL_FUNC (edges_level_callb), data);
gtk_signal_connect (GTK_OBJECT (vds->adj_edges_level), "value_changed", GTK_SIGNAL_FUNC (gboolean_set_false), (gpointer) &hfw->if_calculated);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
// We activate when apply is clicked
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) set_sensitive_callb, (gpointer) vds->wdg_edges_level);
gtk_widget_set_sensitive (GTK_WIDGET(vds->wdg_edges_level),FALSE);
// Controls
gtk_box_pack_start (GTK_BOX (vbox), reset_accept_buttons_new (data, &vds->accept), FALSE, FALSE, DEF_PAD);
gtk_container_add(GTK_CONTAINER(frame), vbox);
return frame;
}
static GtkObject *
gimp_scale_entry_new_internal (gboolean color_scale,
GtkTable *table,
gint column,
gint row,
const gchar *text,
gint scale_width,
gint spinbutton_width,
gdouble value,
gdouble lower,
gdouble upper,
gdouble step_increment,
gdouble page_increment,
guint digits,
gboolean constrain,
gdouble unconstrained_lower,
gdouble unconstrained_upper,
const gchar *tooltip,
const gchar *help_id)
{
GtkWidget *label;
GtkWidget *scale;
GtkWidget *spinbutton;
GtkObject *adjustment;
GtkObject *return_adj;
label = gtk_label_new_with_mnemonic (text);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
column, column + 1, row, row + 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
if (! constrain &&
unconstrained_lower <= lower &&
unconstrained_upper >= upper)
{
GtkObject *constrained_adj;
constrained_adj = gtk_adjustment_new (value, lower, upper,
step_increment, page_increment,
0.0);
spinbutton = gimp_spin_button_new (&adjustment, value,
unconstrained_lower,
unconstrained_upper,
step_increment, page_increment, 0.0,
1.0, digits);
g_signal_connect
(G_OBJECT (constrained_adj), "value-changed",
G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback),
adjustment);
g_signal_connect
(G_OBJECT (adjustment), "value-changed",
G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback),
constrained_adj);
return_adj = adjustment;
adjustment = constrained_adj;
}
else
{
spinbutton = gimp_spin_button_new (&adjustment, value, lower, upper,
step_increment, page_increment, 0.0,
1.0, digits);
return_adj = adjustment;
}
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
if (spinbutton_width > 0)
{
if (spinbutton_width < 17)
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), spinbutton_width);
else
gtk_widget_set_size_request (spinbutton, spinbutton_width, -1);
}
if (color_scale)
{
scale = gimp_color_scale_new (GTK_ORIENTATION_HORIZONTAL,
GIMP_COLOR_SELECTOR_VALUE);
gtk_range_set_adjustment (GTK_RANGE (scale),
GTK_ADJUSTMENT (adjustment));
}
else
{
scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL,
GTK_ADJUSTMENT (adjustment));
}
if (scale_width > 0)
gtk_widget_set_size_request (scale, scale_width, -1);
gtk_scale_set_digits (GTK_SCALE (scale), digits);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_table_attach (GTK_TABLE (table), scale,
column + 1, column + 2, row, row + 1,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_show (scale);
gtk_table_attach (GTK_TABLE (table), spinbutton,
column + 2, column + 3, row, row + 1,
GTK_FILL | GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_widget_show (spinbutton);
if (tooltip || help_id)
{
gimp_help_set_help_data (label, tooltip, help_id);
gimp_help_set_help_data (scale, tooltip, help_id);
gimp_help_set_help_data (spinbutton, tooltip, help_id);
}
g_object_set_data (G_OBJECT (return_adj), "label", label);
g_object_set_data (G_OBJECT (return_adj), "scale", scale);
g_object_set_data (G_OBJECT (return_adj), "spinbutton", spinbutton);
return return_adj;
}
GtkWidget*
create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *accellabel1;
GtkWidget *hscale1;
GtkWidget *label1;
GtkWidget *hscale2;
GtkWidget *dialog_action_area1;
GtkWidget *hbox1;
GtkWidget *button_ok;
GtkWidget *button_ko;
GtkWidget *button_preview;
dialog1 = gtk_dialog_new ();
gtk_object_set_data (GTK_OBJECT (dialog1), "dialog1", dialog1);
gtk_window_set_title (GTK_WINDOW (dialog1), "Clean smoother");
gtk_window_set_policy (GTK_WINDOW (dialog1), TRUE, TRUE, FALSE);
gtk_window_set_modal(GTK_WINDOW(dialog1), TRUE);
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_object_set_data (GTK_OBJECT (dialog1), "dialog_vbox1", dialog_vbox1);
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
accellabel1 = gtk_accel_label_new ("Diameter");
gtk_widget_ref (accellabel1);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "accellabel1", accellabel1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (accellabel1);
gtk_box_pack_start (GTK_BOX (vbox1), accellabel1, FALSE, FALSE, 0);
radius_adj=gtk_adjustment_new (2, 2, 10, 1, 1, 1);
hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (radius_adj));
gtk_widget_ref (hscale1);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "hscale1", hscale1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hscale1);
gtk_box_pack_start (GTK_BOX (vbox1), hscale1, TRUE, TRUE, 0);
gtk_scale_set_digits(GTK_SCALE(hscale1),0);
label1 = gtk_label_new ("Blend amount");
gtk_widget_ref (label1);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "label1", label1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (vbox1), label1, FALSE, FALSE, 0);
blend_adj= gtk_adjustment_new (1, 1, 10, 1, 1, 1);
hscale2 = gtk_hscale_new (GTK_ADJUSTMENT (blend_adj));
gtk_widget_ref (hscale2);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "hscale2", hscale2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_scale_set_digits(GTK_SCALE(hscale2),0);
gtk_widget_show (hscale2);
gtk_box_pack_start (GTK_BOX (vbox1), hscale2, TRUE, TRUE, 0);
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_object_set_data (GTK_OBJECT (dialog1), "dialog_action_area1", dialog_action_area1);
gtk_widget_show (dialog_action_area1);
gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 10);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox1);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "hbox1", hbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbox1, TRUE, TRUE, 0);
button_ok = gtk_button_new_with_label ("OK");
gtk_widget_ref (button_ok);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "button_ok", button_ok,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_ok);
gtk_box_pack_start (GTK_BOX (hbox1), button_ok, FALSE, FALSE, 0);
button_ko = gtk_button_new_with_label ("Cancel");
gtk_widget_ref (button_ko);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "button_ko", button_ko,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_ko);
gtk_box_pack_start (GTK_BOX (hbox1), button_ko, FALSE, FALSE, 0);
button_preview = gtk_button_new_with_label ("Preview");
gtk_widget_ref (button_preview);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "button_preview", button_preview,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_preview);
gtk_box_pack_start (GTK_BOX (hbox1), button_preview, TRUE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button_ok), "clicked",
GTK_SIGNAL_FUNC (gui_ok),
(void *)1);
gtk_signal_connect (GTK_OBJECT (button_ko), "clicked",
GTK_SIGNAL_FUNC (gui_ok),
(void *)0);
return dialog1;
}
GtkWidget*
create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *label1;
GtkObject *spinbutton1_adj;
GtkWidget *spinbutton1;
GtkWidget *hscale1;
GtkWidget *hbox2;
GtkWidget *drawingarea1;
GtkWidget *vscale1;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Subtitle Size and Position"));
gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
label1 = gtk_label_new (QT_TR_NOOP("Font Size:"));
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (hbox1), label1, FALSE, FALSE, 0);
spinbutton1_adj = gtk_adjustment_new (1, 6, 99, 1, 10, 10);
spinbutton1 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton1_adj), 1, 2);
gtk_widget_show (spinbutton1);
gtk_box_pack_start (GTK_BOX (hbox1), spinbutton1, FALSE, FALSE, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton1), TRUE);
hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 99, 1, 1, 1)));
gtk_widget_show (hscale1);
gtk_box_pack_start (GTK_BOX (vbox1), hscale1, FALSE, FALSE, 0);
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox1), hbox2, TRUE, TRUE, 0);
drawingarea1 = gtk_drawing_area_new ();
gtk_widget_show (drawingarea1);
gtk_box_pack_start (GTK_BOX (hbox2), drawingarea1, TRUE, TRUE, 0);
vscale1 = gtk_vscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 100, 1, 1, 1, 1)));
gtk_widget_show (vscale1);
gtk_box_pack_start (GTK_BOX (hbox2), vscale1, FALSE, FALSE, 0);
gtk_scale_set_digits (GTK_SCALE (vscale1), 0);
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, spinbutton1, "spinbutton1");
GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1");
GLADE_HOOKUP_OBJECT (dialog1, hbox2, "hbox2");
GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1");
GLADE_HOOKUP_OBJECT (dialog1, vscale1, "vscale1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
/**
* \fn void dialog_simulator_create()
* \brief Function to create the main window.
*/
void
dialog_simulator_create ()
{
static char *str_exit, *str_options, *str_start, *str_stop, *str_save,
*str_help;
static char *tip_exit, *tip_options, *tip_start, *tip_stop, *tip_save,
*tip_help;
DialogSimulator *dlg;
#if DEBUG
printf ("dialog_simulator_create: start\n");
#endif
dlg = dialog_simulator;
#if HAVE_SDL
exit_event->type = SDL_QUIT;
#endif
str_options = gettext ("_Options");
str_start = gettext ("S_tart");
str_stop = gettext ("Sto_p");
str_save = gettext ("_Save");
str_help = gettext ("_Help");
str_exit = gettext ("E_xit");
tip_options = gettext ("Fractal options");
tip_start = gettext ("Start fractal growing");
tip_stop = gettext ("Stop fractal growing");
tip_save = gettext ("Save graphical");
tip_help = gettext ("Help");
tip_exit = gettext ("Exit");
dlg->toolbar = (GtkToolbar *) gtk_toolbar_new ();
dlg->button_options = (GtkToolButton *) gtk_tool_button_new
(gtk_image_new_from_icon_name
("preferences-system", GTK_ICON_SIZE_SMALL_TOOLBAR), str_options);
gtk_widget_set_tooltip_text (GTK_WIDGET (dlg->button_options), tip_options);
gtk_toolbar_insert (dlg->toolbar, GTK_TOOL_ITEM (dlg->button_options), -1);
g_signal_connect
(dlg->button_options, "clicked", dialog_options_create, NULL);
dlg->button_start = (GtkToolButton *) gtk_tool_button_new
(gtk_image_new_from_icon_name
("system-run", GTK_ICON_SIZE_SMALL_TOOLBAR), str_start);
gtk_widget_set_tooltip_text (GTK_WIDGET (dlg->button_start), tip_start);
gtk_toolbar_insert (dlg->toolbar, GTK_TOOL_ITEM (dlg->button_start), -1);
g_signal_connect (dlg->button_start, "clicked", fractal, NULL);
dlg->button_stop = (GtkToolButton *) gtk_tool_button_new
(gtk_image_new_from_icon_name
("process-stop", GTK_ICON_SIZE_SMALL_TOOLBAR), str_stop);
gtk_widget_set_tooltip_text (GTK_WIDGET (dlg->button_stop), tip_stop);
gtk_toolbar_insert (dlg->toolbar, GTK_TOOL_ITEM (dlg->button_stop), -1);
g_signal_connect (dlg->button_stop, "clicked", fractal_stop, NULL);
dlg->button_save = (GtkToolButton *) gtk_tool_button_new
(gtk_image_new_from_icon_name
("document-save", GTK_ICON_SIZE_SMALL_TOOLBAR), str_save);
gtk_widget_set_tooltip_text (GTK_WIDGET (dlg->button_save), tip_save);
gtk_toolbar_insert (dlg->toolbar, GTK_TOOL_ITEM (dlg->button_save), -1);
g_signal_connect (dlg->button_save, "clicked", dialog_simulator_save, NULL);
dlg->button_help = (GtkToolButton *) gtk_tool_button_new
(gtk_image_new_from_icon_name
("help-about", GTK_ICON_SIZE_SMALL_TOOLBAR), str_help);
gtk_widget_set_tooltip_text (GTK_WIDGET (dlg->button_help), tip_help);
gtk_toolbar_insert (dlg->toolbar, GTK_TOOL_ITEM (dlg->button_help), -1);
g_signal_connect (dlg->button_help, "clicked", dialog_simulator_help, NULL);
dlg->button_exit = (GtkToolButton *) gtk_tool_button_new
(gtk_image_new_from_icon_name
("application-exit", GTK_ICON_SIZE_SMALL_TOOLBAR), str_exit);
gtk_widget_set_tooltip_text (GTK_WIDGET (dlg->button_exit), tip_exit);
gtk_toolbar_insert (dlg->toolbar, GTK_TOOL_ITEM (dlg->button_exit), -1);
#if HAVE_FREEGLUT
g_signal_connect (dlg->button_exit, "clicked", glutLeaveMainLoop, NULL);
#elif HAVE_SDL
g_signal_connect_swapped (dlg->button_exit, "clicked",
(void (*)) SDL_PushEvent, exit_event);
#elif HAVE_GLFW
g_signal_connect (dlg->button_exit, "clicked", (void (*)) window_close, NULL);
#endif
dlg->label_time = (GtkLabel *) gtk_label_new (gettext ("Calculating time"));
dlg->entry_time =
(GtkSpinButton *) gtk_spin_button_new_with_range (0., 1.e6, 0.1);
gtk_widget_set_sensitive (GTK_WIDGET (dlg->entry_time), 0);
dlg->progress = (GtkProgressBar *) gtk_progress_bar_new ();
gtk_progress_bar_set_text (dlg->progress, gettext ("Progress"));
dlg->hscale = (GtkScale *) gtk_scale_new_with_range
(GTK_ORIENTATION_HORIZONTAL, -90., 0., 1.);
dlg->vscale = (GtkScale *) gtk_scale_new_with_range
(GTK_ORIENTATION_HORIZONTAL, 0., 90., 1.);
gtk_scale_set_digits (dlg->hscale, 0);
gtk_scale_set_digits (dlg->vscale, 0);
gtk_range_set_value (GTK_RANGE (dlg->hscale), phid);
gtk_range_set_value (GTK_RANGE (dlg->vscale), thetad);
g_signal_connect (dlg->hscale, "value-changed", set_perspective, NULL);
g_signal_connect (dlg->vscale, "value-changed", set_perspective, NULL);
dlg->label_horizontal = (GtkLabel *) gtk_label_new
(gettext ("Horizontal perspective angle (º)"));
dlg->label_vertical = (GtkLabel *) gtk_label_new
(gettext ("Vertical perspective angle (º)"));
dlg->grid = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->toolbar), 0, 0, 3, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->progress), 0, 1, 1, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->label_time), 1, 1, 1, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->entry_time), 2, 1, 1, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->label_horizontal), 0, 2, 1, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->hscale), 1, 2, 2, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->label_vertical), 0, 3, 1, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->vscale), 1, 3, 2, 1);
dlg->logo = gtk_image_get_pixbuf
(GTK_IMAGE (gtk_image_new_from_file ("logo.png")));
dlg->logo_min = gtk_image_get_pixbuf
(GTK_IMAGE (gtk_image_new_from_file ("logo2.png")));
dlg->window = (GtkWindow *) gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (dlg->window, gettext ("Fractal growing"));
gtk_window_set_icon (dlg->window, dlg->logo_min);
gtk_container_add (GTK_CONTAINER (dlg->window), GTK_WIDGET (dlg->grid));
gtk_widget_show_all (GTK_WIDGET (dlg->window));
#if HAVE_FREEGLUT
g_signal_connect (dlg->window, "delete_event", glutLeaveMainLoop, NULL);
#elif HAVE_SDL
g_signal_connect_swapped (dlg->window, "delete_event",
(void (*)) SDL_PushEvent, exit_event);
#elif HAVE_GLFW
g_signal_connect (dlg->window, "delete_event", (void (*)) window_close, NULL);
#endif
set_perspective ();
dialog_simulator_update ();
#if DEBUG
printf ("dialog_simulator_create: end\n");
#endif
}
GtkWidget*
create_threshold_dialog (void)
{
GtkWidget *threshold_dialog;
GtkWidget *dialogVbox;
GtkWidget *allButButtonsVbox;
GtkWidget *settingsOuterHbox;
GtkWidget *settingsOuterVbox;
GtkWidget *minValueVbox;
GtkWidget *minValueLabel;
GtkWidget *minValueHbox;
GtkWidget *minValueSlider;
GtkObject *minValueSpinner_adj;
GtkWidget *minValueSpinner;
GtkWidget *maxValueVbox;
GtkWidget *maxValueLabel;
GtkWidget *maxValueHbox;
GtkWidget *maxValueSlider;
GtkObject *maxValueSpinner_adj;
GtkWidget *maxValueSpinner;
GtkWidget *outputValuesHbox;
GtkWidget *outputValuesLabel;
GtkWidget *outputValuesMenu;
GtkWidget *debugHbox;
GtkWidget *debugLabel;
GtkObject *debugSpinButton_adj;
GtkWidget *debugSpinButton;
GtkWidget *previewFrame;
GtkWidget *previewAlignment;
GtkWidget *previewVbox;
GtkWidget *previewControlHbox;
GtkWidget *previewOutputMenu;
GtkWidget *previewSlider;
GtkWidget *previewVideo;
GtkWidget *previewLabel;
GtkWidget *dialogButtonBox;
GtkWidget *cancelButton;
GtkWidget *okButton;
threshold_dialog = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (threshold_dialog), QT_TR_NOOP("Threshold"));
gtk_window_set_type_hint (GTK_WINDOW (threshold_dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
dialogVbox = GTK_DIALOG (threshold_dialog)->vbox;
gtk_widget_show (dialogVbox);
allButButtonsVbox = gtk_vbox_new (FALSE, 12);
gtk_widget_show (allButButtonsVbox);
gtk_box_pack_start (GTK_BOX (dialogVbox), allButButtonsVbox, TRUE, TRUE, 0);
settingsOuterHbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (settingsOuterHbox);
gtk_box_pack_start (GTK_BOX (allButButtonsVbox), settingsOuterHbox, FALSE, TRUE, 0);
settingsOuterVbox = gtk_vbox_new (FALSE, 12);
gtk_widget_show (settingsOuterVbox);
gtk_box_pack_start (GTK_BOX (settingsOuterHbox), settingsOuterVbox, TRUE, TRUE, 0);
minValueVbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (minValueVbox);
gtk_box_pack_start (GTK_BOX (settingsOuterVbox), minValueVbox, FALSE, FALSE, 0);
minValueLabel = gtk_label_new (QT_TR_NOOP("Minimum value to be in-range:"));
gtk_widget_show (minValueLabel);
gtk_box_pack_start (GTK_BOX (minValueVbox), minValueLabel, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (minValueLabel), 0.5, 1);
gtk_misc_set_padding (GTK_MISC (minValueLabel), 0, 8);
minValueHbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (minValueHbox);
gtk_box_pack_start (GTK_BOX (minValueVbox), minValueHbox, TRUE, TRUE, 0);
#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE
minValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 255, 1, 1, 0)));
#else
minValueSpinner_adj = gtk_adjustment_new (0, 0, 255, 1, 1, 0);
minValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (minValueSpinner_adj));
#endif
gtk_widget_show (minValueSlider);
gtk_box_pack_start (GTK_BOX (minValueHbox), minValueSlider, TRUE, TRUE, 0);
gtk_scale_set_draw_value (GTK_SCALE (minValueSlider), FALSE);
gtk_scale_set_value_pos (GTK_SCALE (minValueSlider), GTK_POS_LEFT);
gtk_scale_set_digits (GTK_SCALE (minValueSlider), 0);
#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE
minValueSpinner_adj = gtk_adjustment_new (0, 0, 255, 1, 10, 10);
#endif
minValueSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (minValueSpinner_adj), 1, 0);
gtk_widget_show (minValueSpinner);
gtk_box_pack_start (GTK_BOX (minValueHbox), minValueSpinner, FALSE, TRUE, 0);
maxValueVbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (maxValueVbox);
gtk_box_pack_start (GTK_BOX (settingsOuterVbox), maxValueVbox, FALSE, FALSE, 0);
maxValueLabel = gtk_label_new (QT_TR_NOOP("Maximum value to be in-range:"));
gtk_widget_show (maxValueLabel);
gtk_box_pack_start (GTK_BOX (maxValueVbox), maxValueLabel, FALSE, FALSE, 0);
maxValueHbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (maxValueHbox);
gtk_box_pack_start (GTK_BOX (maxValueVbox), maxValueHbox, TRUE, TRUE, 0);
#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE
maxValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (255, 0, 255, 1, 1, 0)));
#else
maxValueSpinner_adj = gtk_adjustment_new (255, 0, 255, 1, 1, 0);
maxValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (maxValueSpinner_adj));
#endif
gtk_widget_show (maxValueSlider);
gtk_box_pack_start (GTK_BOX (maxValueHbox), maxValueSlider, TRUE, TRUE, 0);
gtk_scale_set_draw_value (GTK_SCALE (maxValueSlider), FALSE);
gtk_scale_set_value_pos (GTK_SCALE (maxValueSlider), GTK_POS_LEFT);
gtk_scale_set_digits (GTK_SCALE (maxValueSlider), 0);
#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE
maxValueSpinner_adj = gtk_adjustment_new (255, 0, 255, 1, 10, 10);
#endif
maxValueSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (maxValueSpinner_adj), 1, 0);
gtk_widget_show (maxValueSpinner);
gtk_box_pack_start (GTK_BOX (maxValueHbox), maxValueSpinner, FALSE, TRUE, 0);
outputValuesHbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (outputValuesHbox);
gtk_box_pack_start (GTK_BOX (settingsOuterVbox), outputValuesHbox, TRUE, TRUE, 0);
outputValuesLabel = gtk_label_new (QT_TR_NOOP("Output values: "));
gtk_widget_show (outputValuesLabel);
gtk_box_pack_start (GTK_BOX (outputValuesHbox), outputValuesLabel, FALSE, FALSE, 0);
outputValuesMenu = gtk_combo_box_new_text ();
gtk_widget_show (outputValuesMenu);
gtk_box_pack_start (GTK_BOX (outputValuesHbox), outputValuesMenu, TRUE, TRUE, 0);
gtk_combo_box_append_text (GTK_COMBO_BOX (outputValuesMenu), QT_TR_NOOP("In-range values go black, out-of-range values go white"));
gtk_combo_box_append_text (GTK_COMBO_BOX (outputValuesMenu), QT_TR_NOOP("In-range values go white, out-of-range values go black"));
debugHbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (debugHbox);
gtk_box_pack_start (GTK_BOX (settingsOuterVbox), debugHbox, TRUE, TRUE, 0);
debugLabel = gtk_label_new (QT_TR_NOOP("Debugging settings (bits): "));
gtk_widget_show (debugLabel);
gtk_box_pack_start (GTK_BOX (debugHbox), debugLabel, FALSE, FALSE, 0);
debugSpinButton_adj = gtk_adjustment_new (0, 0, 16777215, 1, 10, 10);
debugSpinButton = gtk_spin_button_new (GTK_ADJUSTMENT (debugSpinButton_adj), 1, 0);
gtk_widget_show (debugSpinButton);
gtk_box_pack_start (GTK_BOX (debugHbox), debugSpinButton, TRUE, TRUE, 0);
previewFrame = gtk_frame_new (NULL);
gtk_widget_show (previewFrame);
gtk_box_pack_start (GTK_BOX (allButButtonsVbox), previewFrame, TRUE, TRUE, 0);
previewAlignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (previewAlignment);
gtk_container_add (GTK_CONTAINER (previewFrame), previewAlignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (previewAlignment), 0, 8, 6, 8);
previewVbox = gtk_vbox_new (FALSE, 5);
gtk_widget_show (previewVbox);
gtk_container_add (GTK_CONTAINER (previewAlignment), previewVbox);
previewControlHbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (previewControlHbox);
gtk_box_pack_start (GTK_BOX (previewVbox), previewControlHbox, TRUE, TRUE, 0);
previewOutputMenu = gtk_combo_box_new_text ();
gtk_widget_show (previewOutputMenu);
gtk_box_pack_start (GTK_BOX (previewControlHbox), previewOutputMenu, FALSE, TRUE, 0);
previewSlider = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 99, 1, 1, 1)));
gtk_widget_show (previewSlider);
gtk_box_pack_start (GTK_BOX (previewControlHbox), previewSlider, TRUE, TRUE, 0);
gtk_scale_set_digits (GTK_SCALE (previewSlider), 0);
previewVideo = gtk_drawing_area_new ();
gtk_widget_show (previewVideo);
gtk_box_pack_start (GTK_BOX (previewVbox), previewVideo, TRUE, TRUE, 0);
gtk_widget_set_size_request (previewVideo, 30, 30);
gtk_widget_set_events (previewVideo, GDK_BUTTON1_MOTION_MASK | GDK_BUTTON_PRESS_MASK);
previewLabel = gtk_label_new (QT_TR_NOOP("Preview"));
gtk_widget_show (previewLabel);
gtk_frame_set_label_widget (GTK_FRAME (previewFrame), previewLabel);
dialogButtonBox = GTK_DIALOG (threshold_dialog)->action_area;
gtk_widget_show (dialogButtonBox);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialogButtonBox), GTK_BUTTONBOX_END);
cancelButton = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelButton);
gtk_dialog_add_action_widget (GTK_DIALOG (threshold_dialog), cancelButton, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelButton, GTK_CAN_DEFAULT);
okButton = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okButton);
gtk_dialog_add_action_widget (GTK_DIALOG (threshold_dialog), okButton, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okButton, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (threshold_dialog, threshold_dialog, "threshold_dialog");
GLADE_HOOKUP_OBJECT_NO_REF (threshold_dialog, dialogVbox, "dialogVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, allButButtonsVbox, "allButButtonsVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, settingsOuterHbox, "settingsOuterHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, settingsOuterVbox, "settingsOuterVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueVbox, "minValueVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueLabel, "minValueLabel");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueHbox, "minValueHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueSlider, "minValueSlider");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueSpinner, "minValueSpinner");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueVbox, "maxValueVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueLabel, "maxValueLabel");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueHbox, "maxValueHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueSlider, "maxValueSlider");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueSpinner, "maxValueSpinner");
GLADE_HOOKUP_OBJECT (threshold_dialog, outputValuesHbox, "outputValuesHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, outputValuesLabel, "outputValuesLabel");
GLADE_HOOKUP_OBJECT (threshold_dialog, outputValuesMenu, "outputValuesMenu");
GLADE_HOOKUP_OBJECT (threshold_dialog, debugHbox, "debugHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, debugLabel, "debugLabel");
GLADE_HOOKUP_OBJECT (threshold_dialog, debugSpinButton, "debugSpinButton");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewFrame, "previewFrame");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewAlignment, "previewAlignment");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewVbox, "previewVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewControlHbox, "previewControlHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewOutputMenu, "previewOutputMenu");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewSlider, "previewSlider");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewVideo, "previewVideo");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewLabel, "previewLabel");
GLADE_HOOKUP_OBJECT_NO_REF (threshold_dialog, dialogButtonBox, "dialogButtonBox");
GLADE_HOOKUP_OBJECT (threshold_dialog, cancelButton, "cancelButton");
GLADE_HOOKUP_OBJECT (threshold_dialog, okButton, "okButton");
return threshold_dialog;
}
static void fill_sample_table(DrMrUi* ui, int samples, char** names,GtkWidget** gain_sliders, GtkWidget** pan_sliders) {
int row = 0;
int col = 0;
int si;
gchar buf[64];
int rows = (samples/ui->cols);
if (samples % ui->cols != 0) rows++;
gtk_table_resize(ui->sample_table,rows,ui->cols);
switch (ui->startSamp) {
case 1: // bottom left
row = rows-1;
break;
case 2: // top right
col = ui->cols-1;
break;
case 3: // bottom right
row = rows-1;
col = ui->cols-1;
break;
}
for(si = 0;si<samples;si++) {
GtkWidget *frame,*hbox,*gain_vbox,*pan_vbox;
GtkWidget* gain_slider;
GtkWidget* pan_slider;
GtkWidget* gain_label;
GtkWidget* pan_label;
gboolean slide_expand;
snprintf(buf,64,"<b>%s</b> (%i)",names[si],si);
frame = gtk_frame_new(buf);
gtk_label_set_use_markup(GTK_LABEL(gtk_frame_get_label_widget(GTK_FRAME(frame))),true);
gtk_frame_set_shadow_type(GTK_FRAME(frame),GTK_SHADOW_OUT);
hbox = gtk_hbox_new(false,0);
#ifdef NO_NKNOB
gain_slider = gtk_vscale_new_with_range(GAIN_MIN,6.0,1.0);
gtk_scale_set_value_pos(GTK_SCALE(gain_slider),GTK_POS_BOTTOM);
gtk_scale_set_digits(GTK_SCALE(gain_slider),1);
gtk_scale_add_mark(GTK_SCALE(gain_slider),0.0,GTK_POS_RIGHT,"0 dB");
// Hrmm, -inf label is at top in ardour for some reason
//gtk_scale_add_mark(GTK_SCALE(gain_slider),GAIN_MIN,GTK_POS_RIGHT,"-inf");
gtk_range_set_inverted(GTK_RANGE(gain_slider),true);
slide_expand = true;
#else
gain_slider = n_knob_new_with_range(0.0,GAIN_MIN,6.0,1.0);
n_knob_set_load_prefix(N_KNOB(gain_slider),ui->bundle_path);
gtk_widget_set_has_tooltip(gain_slider,TRUE);
slide_expand = false;
#endif
g_object_set_qdata (G_OBJECT(gain_slider),ui->gain_quark,GINT_TO_POINTER(si));
if (gain_sliders) gain_sliders[si] = gain_slider;
if (si < 32)
gtk_range_set_value(GTK_RANGE(gain_slider),ui->gain_vals[si]);
else // things are gross if we have > 32 samples, what to do?
gtk_range_set_value(GTK_RANGE(gain_slider),0.0);
g_signal_connect(G_OBJECT(gain_slider),"change-value",G_CALLBACK(gain_callback),ui);
gain_label = gtk_label_new("Gain");
gain_vbox = gtk_vbox_new(false,0);
#ifdef NO_NKNOB
pan_slider = gtk_hscale_new_with_range(-1.0,1.0,0.1);
gtk_scale_add_mark(GTK_SCALE(pan_slider),0.0,GTK_POS_TOP,NULL);
#else
pan_slider = n_knob_new_with_range(0.0,-1.0,1.0,0.1);
n_knob_set_load_prefix(N_KNOB(pan_slider),ui->bundle_path);
gtk_widget_set_has_tooltip(pan_slider,TRUE);
#endif
if (pan_sliders) pan_sliders[si] = pan_slider;
if (si < 32)
gtk_range_set_value(GTK_RANGE(pan_slider),ui->pan_vals[si]);
else
gtk_range_set_value(GTK_RANGE(pan_slider),0);
g_object_set_qdata (G_OBJECT(pan_slider),ui->pan_quark,GINT_TO_POINTER(si));
g_signal_connect(G_OBJECT(pan_slider),"change-value",G_CALLBACK(pan_callback),ui);
pan_label = gtk_label_new("Pan");
pan_vbox = gtk_vbox_new(false,0);
gtk_box_pack_start(GTK_BOX(gain_vbox),gain_slider,slide_expand,slide_expand,0);
gtk_box_pack_start(GTK_BOX(gain_vbox),gain_label,false,false,0);
gtk_box_pack_start(GTK_BOX(pan_vbox),pan_slider,slide_expand,slide_expand,0);
gtk_box_pack_start(GTK_BOX(pan_vbox),pan_label,false,false,0);
gtk_box_pack_start(GTK_BOX(hbox),gain_vbox,true,true,0);
gtk_box_pack_start(GTK_BOX(hbox),pan_vbox,true,true,0);
gtk_container_add(GTK_CONTAINER(frame),hbox);
gtk_table_attach_defaults(ui->sample_table,frame,col,col+1,row,row+1);
if (ui->startSamp > 1) {
col--;
if (col < 0) {
if (ui->startSamp == 2)
row++;
else
row--;
col = ui->cols-1;
}
}
else {
col++;
if (col >= ui->cols) {
if (ui->startSamp == 0)
row++;
else
row--;
col = 0;
}
}
}
gtk_widget_queue_resize(GTK_WIDGET(ui->sample_table));
}
void
_showInGtkWindow (SEXP xx, SEXP caption) {
int nx, ny, nz, width, height;
udata *dat;
SEXP dim;
GdkPixbuf * pxbuf;
GtkWidget *evBox, *winWG, *vboxWG, *tbarWG, *scrollWG,
*btnZoomInWG, *btnZoomOutWG, *btnZoomOneWG,
*btnNextWG, *btnPrevWG;
GtkObject *hAdjustment;
GtkIconSize iSize;
if ( !GTK_OK )
error ( "failed to initialize GTK+, use 'read.image' instead" );
dim = GET_DIM (xx);
nx = INTEGER (dim)[0];
ny = INTEGER (dim)[1];
nz = getNumberOfFrames(xx,1);
dat=g_new(udata,1);
dat->nx=nx;
dat->ny=ny;
dat->nz=nz;
dat->x=0;
dat->y=0;
dat->zoom=1.0;
dat->index=0;
dat->hSlider=NULL;
dat->xx=xx;
// xx is preserved from garbage collection til the windows is closed
R_PreserveObject(xx);
/* create pixbuf from image data */
pxbuf=newPixbufFromSEXP(xx,0);
if ( pxbuf == NULL )
error ( "cannot copy image data to display window" );
/* create imae display */
dat->imgWG = gtk_image_new_from_pixbuf (pxbuf);
g_object_unref (pxbuf);
/* create main window */
winWG = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if ( caption != R_NilValue )
gtk_window_set_title ( GTK_WINDOW(winWG), CHAR( asChar(caption) ) );
else
gtk_window_set_title ( GTK_WINDOW(winWG), "R image display" );
/* set destroy event handler for the window */
g_signal_connect ( G_OBJECT(winWG), "delete-event", G_CALLBACK(onWinDestroy), dat);
/* create controls and set event handlers */
/* create general horizontal lyout with a toolbar and add it to the window */
vboxWG = gtk_vbox_new (FALSE, 0);
gtk_container_add ( GTK_CONTAINER(winWG), vboxWG);
/* create toolbar and push it to layout */
tbarWG = gtk_toolbar_new ();
gtk_box_pack_start ( GTK_BOX(vboxWG), tbarWG, FALSE, FALSE, 0);
// add a horizontal slider
if (nz>1) {
hAdjustment=gtk_adjustment_new(1,1,nz,1,1,0);
dat->hSlider=gtk_hscale_new(GTK_ADJUSTMENT(hAdjustment));
gtk_scale_set_digits(GTK_SCALE(dat->hSlider),0);
gtk_box_pack_start(GTK_BOX(vboxWG), dat->hSlider, FALSE,FALSE, 0);
gtk_signal_connect(GTK_OBJECT(dat->hSlider),"value-changed", GTK_SIGNAL_FUNC(onSlide), dat);
}
/* create scrollbox that occupies and extends and push it to layout */
scrollWG = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start ( GTK_BOX(vboxWG), scrollWG, TRUE, TRUE, 5);
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrollWG), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* add image to event box */
evBox = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(evBox), dat->imgWG);
/* add image to scroll */
gtk_scrolled_window_add_with_viewport ( GTK_SCROLLED_WINDOW(scrollWG), evBox);
gtk_signal_connect(GTK_OBJECT(gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(scrollWG))),"value-changed", GTK_SIGNAL_FUNC(onScroll), dat);
gtk_signal_connect(GTK_OBJECT(gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(scrollWG))),"value-changed", GTK_SIGNAL_FUNC(onScroll), dat);
/* create status bar and push it to layout */
dat->stbarWG = gtk_statusbar_new ();
gtk_box_pack_start ( GTK_BOX(vboxWG), dat->stbarWG, FALSE, FALSE, 0);
/* add zoom buttons */
iSize = gtk_toolbar_get_icon_size ( GTK_TOOLBAR(tbarWG) );
btnZoomInWG = (GtkWidget *) gtk_tool_button_new ( gtk_image_new_from_stock("gtk-zoom-in", iSize), "Zoom in" );
gtk_container_add ( GTK_CONTAINER(tbarWG), btnZoomInWG);
g_signal_connect ( G_OBJECT(btnZoomInWG), "clicked", G_CALLBACK(onZoomInPress), dat);
btnZoomOutWG = (GtkWidget *) gtk_tool_button_new ( gtk_image_new_from_stock("gtk-zoom-out", iSize), "Zoom out" );
gtk_container_add ( GTK_CONTAINER(tbarWG), btnZoomOutWG);
g_signal_connect ( G_OBJECT(btnZoomOutWG), "clicked", G_CALLBACK(onZoomOutPress), dat);
btnZoomOneWG = (GtkWidget *) gtk_tool_button_new ( gtk_image_new_from_stock("gtk-yes", iSize), "1:1");
gtk_container_add ( GTK_CONTAINER(tbarWG), btnZoomOneWG);
g_signal_connect ( G_OBJECT(btnZoomOneWG), "clicked", G_CALLBACK(onZoomOnePress), dat);
/* add browsing buttons */
if ( nz > 1 ) {
btnPrevWG = (GtkWidget *) gtk_tool_button_new ( gtk_image_new_from_stock("gtk-go-back", iSize), "Previous" );
gtk_container_add ( GTK_CONTAINER(tbarWG), btnPrevWG);
g_signal_connect ( G_OBJECT(btnPrevWG), "clicked", G_CALLBACK(onPrevImPress), dat);
btnNextWG = (GtkWidget *) gtk_tool_button_new ( gtk_image_new_from_stock("gtk-go-forward", iSize), "Next" );
gtk_container_add ( GTK_CONTAINER(tbarWG), btnNextWG);
g_signal_connect ( G_OBJECT(btnNextWG), "clicked", G_CALLBACK(onNextImPress), dat);
}
gtk_signal_connect( GTK_OBJECT(evBox), "motion-notify-event", GTK_SIGNAL_FUNC(onMouseMove), dat);
gtk_widget_set_events(evBox, GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK );
/* resize to fit image */
width = gdk_screen_get_width ( gdk_screen_get_default() );
height = gdk_screen_get_height ( gdk_screen_get_default () );
width = ( nx + 20 < width - 20 ) ? ( nx + 20 ) : ( width - 20 );
height = ( ny + 80 < height - 20 ) ? ( ny + 80 ) : ( height - 20 );
if ( width < 150 ) width = 150;
if ( height < 100 ) height = 100;
gtk_window_resize ( GTK_WINDOW(winWG), width, height);
/* show window */
gtk_widget_show_all (winWG);
updateStatusBar(dat);
gdk_flush();
}
void uade_gui_seek_subsong(int to)
{
GtkWidget *seek_button_box;
GtkWidget *prev_next_button_box;
GtkWidget *seek_button_vbox;
GtkWidget *seek_slider_box;
GtkWidget *hscale;
GtkWidget *prev_button;
GtkWidget *prev_button_frame;
GtkWidget *frame;
GtkWidget *maxsong_label;
GtkWidget *next_button,*ffwd_button;
GtkWidget *ffwd_button_frame;
if (!uade_thread_running) {
fprintf(stderr, "uade: BUG! Seek not possible.\n");
return;
}
if (seekpopup == NULL) {
/* uade's subsong popup */
seekpopup = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(seekpopup), "UADE seek subsong");
gtk_window_set_position(GTK_WINDOW(seekpopup), GTK_WIN_POS_MOUSE);
gtk_container_set_border_width(GTK_CONTAINER(seekpopup), 0);
gtk_window_set_policy(GTK_WINDOW(seekpopup), FALSE, FALSE, FALSE);
gtk_signal_connect(GTK_OBJECT(seekpopup), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&seekpopup);
gtk_signal_connect(GTK_OBJECT(seekpopup), "focus_out_event",
GTK_SIGNAL_FUNC(focus_out_event), NULL);
gtk_widget_realize(seekpopup);
gdk_window_set_decorations(seekpopup->window, 0);
/* define Slider code, will be used by all styles of the popup */
if (uade_get_max_subsong(-1) >= 0) {
subsong_adj =
gtk_adjustment_new(uade_get_cur_subsong(0), uade_get_min_subsong(0),
uade_get_max_subsong(0), 1, 0, 0); /*our scale for the subsong slider */
maxsong_label =
gtk_label_new(g_strdup_printf("%d", uade_get_max_subsong(0))); /* until we can't get the reliable maximum number of subsongs this has to do :-) */
gtk_widget_set_usize(maxsong_label, 24, -1);
} else {
subsong_adj =
gtk_adjustment_new(uade_get_cur_subsong(0), uade_get_min_subsong(0),
(uade_get_max_subsong(0)) + 10, 1, 0, 0); /*our scale for the subsong slider */
/*currently: min - min+10 */
maxsong_label = gtk_label_new("..."); /* until we can't get the reliable maximum number of subsongs this has to do :-) */
gtk_widget_set_usize(maxsong_label, 24, -1);
}
hscale = gtk_hscale_new(GTK_ADJUSTMENT(subsong_adj));
gtk_widget_set_usize(hscale, 160, -1);
gtk_scale_set_digits(GTK_SCALE(hscale), 0);
gtk_scale_set_value_pos(GTK_SCALE(hscale), GTK_POS_LEFT);
gtk_scale_set_draw_value(GTK_SCALE(hscale), TRUE);
gtk_range_set_update_policy(GTK_RANGE(hscale),
GTK_UPDATE_DISCONTINUOUS);
gtk_signal_connect_object(GTK_OBJECT(subsong_adj), "value_changed",
GTK_SIGNAL_FUNC(uade_seek_directly),
NULL);
/* previous subsong button, will be used by all styles of the seek popup*/
prev_button = gtk_button_new_with_label("<");
gtk_widget_set_usize(prev_button, 27, -1);
gtk_signal_connect_object(GTK_OBJECT(prev_button), "clicked",
GTK_SIGNAL_FUNC(uade_seek_previous),
NULL);
prev_button_frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(prev_button_frame),
GTK_SHADOW_IN);
/* next subsong button, will be used by all styles of the seek popup*/
next_button = gtk_button_new_with_label(">");
gtk_widget_set_usize(next_button, 27, -1);
gtk_signal_connect_object(GTK_OBJECT(next_button), "clicked",
GTK_SIGNAL_FUNC(uade_seek_next), NULL);
ffwd_button_frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(ffwd_button_frame),
GTK_SHADOW_IN);
ffwd_button = gtk_button_new_with_label("10s fwd");
gtk_widget_set_usize(ffwd_button, 27, -1);
gtk_signal_connect_object(GTK_OBJECT(ffwd_button), "clicked",
GTK_SIGNAL_FUNC(uade_ffwd), NULL);
/* with the alternative styles of the subsongseeker,
* following suggestions made by David Le Corfec*/
seek_button_box = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(seekpopup), seek_button_box);
frame = gtk_frame_new(NULL);
gtk_box_pack_start_defaults(GTK_BOX(seek_button_box), frame);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
seek_button_vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), seek_button_vbox);
gtk_signal_connect(GTK_OBJECT(seek_button_vbox), "focus_out_event",
GTK_SIGNAL_FUNC(focus_out_event), NULL);
prev_next_button_box = gtk_hbox_new(FALSE, 0);
/* use the previous defined buttons here */
gtk_box_pack_start_defaults(GTK_BOX(seek_button_vbox),
prev_button_frame);
gtk_container_add(GTK_CONTAINER(prev_button_frame),
prev_next_button_box);
gtk_box_pack_start_defaults(GTK_BOX(prev_next_button_box),
prev_button);
gtk_box_pack_start_defaults(GTK_BOX(prev_next_button_box),
next_button);
seek_slider_box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(seek_button_vbox), seek_slider_box,
FALSE, FALSE, 0);
/* use the previous defined slider and label here */
gtk_box_pack_start(GTK_BOX(seek_slider_box), hscale, FALSE, FALSE,
0);
gtk_box_pack_start(GTK_BOX(seek_slider_box), maxsong_label, FALSE,
FALSE, 0);
/* use the previous defined buttons here */
gtk_box_pack_start_defaults(GTK_BOX(seek_button_vbox),
ffwd_button_frame);
gtk_container_add(GTK_CONTAINER(ffwd_button_frame),
ffwd_button);
gtk_widget_show_all(seekpopup);
seekpopup_open = 1;
} else {
gdk_window_raise(seekpopup->window);
}
}
static int
icvCreateTrackbar( const char* trackbar_name, const char* window_name,
int* val, int count, CvTrackbarCallback on_notify,
CvTrackbarCallback2 on_notify2, void* userdata )
{
int result = 0;
CV_FUNCNAME( "icvCreateTrackbar" );
__BEGIN__;
/*char slider_name[32];*/
CvWindow* window = 0;
CvTrackbar* trackbar = 0;
if( !window_name || !trackbar_name )
CV_ERROR( CV_StsNullPtr, "NULL window or trackbar name" );
if( count <= 0 )
CV_ERROR( CV_StsOutOfRange, "Bad trackbar maximal value" );
window = icvFindWindowByName(window_name);
if( !window )
EXIT;
trackbar = icvFindTrackbarByName(window,trackbar_name);
CV_LOCK_MUTEX();
if( !trackbar )
{
int len = strlen(trackbar_name);
trackbar = (CvTrackbar*)cvAlloc(sizeof(CvTrackbar) + len + 1);
memset( trackbar, 0, sizeof(*trackbar));
trackbar->signature = CV_TRACKBAR_MAGIC_VAL;
trackbar->name = (char*)(trackbar+1);
memcpy( trackbar->name, trackbar_name, len + 1 );
trackbar->parent = window;
trackbar->next = window->toolbar.first;
window->toolbar.first = trackbar;
GtkWidget* hscale_box = gtk_hbox_new( FALSE, 10 );
GtkWidget* hscale_label = gtk_label_new( trackbar_name );
GtkWidget* hscale = gtk_hscale_new_with_range( 0, count, 1 );
gtk_scale_set_digits( GTK_SCALE(hscale), 0 );
//gtk_scale_set_value_pos( hscale, GTK_POS_TOP );
gtk_scale_set_draw_value( GTK_SCALE(hscale), TRUE );
trackbar->widget = hscale;
gtk_box_pack_start( GTK_BOX(hscale_box), hscale_label, FALSE, FALSE, 5 );
gtk_widget_show( hscale_label );
gtk_box_pack_start( GTK_BOX(hscale_box), hscale, TRUE, TRUE, 5 );
gtk_widget_show( hscale );
gtk_box_pack_start( GTK_BOX(window->paned), hscale_box, FALSE, FALSE, 5 );
gtk_widget_show( hscale_box );
}
if( val )
{
int value = *val;
if( value < 0 )
value = 0;
if( value > count )
value = count;
gtk_range_set_value( GTK_RANGE(trackbar->widget), value );
trackbar->pos = value;
trackbar->data = val;
}
trackbar->maxval = count;
trackbar->notify = on_notify;
trackbar->notify2 = on_notify2;
trackbar->userdata = userdata;
g_signal_connect( trackbar->widget, "value-changed",
G_CALLBACK(icvOnTrackbar), trackbar );
// queue a widget resize to trigger a window resize to
// compensate for the addition of trackbars
gtk_widget_queue_resize( GTK_WIDGET(window->widget) );
CV_UNLOCK_MUTEX();
result = 1;
__END__;
return result;
}
plugin_strip *
create_plugin_strip(GtkWidget *parent_window, d3h_instance_t *instance)
{
plugin_strip *ps = (plugin_strip *)calloc(1, sizeof(plugin_strip));
GtkWidget *vbox1;
char buf[12];
GtkWidget *hbox1;
GtkWidget *striplabel1;
GtkWidget *striplabel2;
GtkWidget *hbox2;
#if 0
GtkWidget *config_button;
#endif
#if 0
GtkWidget *hscale1;
GtkWidget *vscale1;
#endif
ps->instance = instance;
ps->container = gtk_frame_new (NULL);
gtk_widget_ref (ps->container);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "frame1", ps->container,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (ps->container);
gtk_container_set_border_width (GTK_CONTAINER (ps->container), 2);
gtk_frame_set_shadow_type (GTK_FRAME (ps->container), GTK_SHADOW_OUT);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (ps->container), vbox1);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox1);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "hbox1", hbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
ps->midi_status = blinky_new(0);
gtk_widget_ref (ps->midi_status);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "midi_status", ps->midi_status,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (ps->midi_status);
gtk_box_pack_start (GTK_BOX (hbox1), ps->midi_status, FALSE, FALSE, 1);
ps->previous_midi_state = 0;
snprintf(buf, 12, "Inst %d", instance->id);
striplabel1 = gtk_label_new (buf);
gtk_widget_ref (striplabel1);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "striplabel1", striplabel1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (striplabel1);
gtk_box_pack_start (GTK_BOX (hbox1), striplabel1, FALSE, FALSE, 1);
/* gtk_misc_set_alignment (GTK_MISC (striplabel1), 0, 0.5); -FIX- */
/* gtk_misc_set_padding (GTK_MISC (striplabel1), 3, 0); -FIX- */
snprintf(buf, 12, "%s", instance->plugin->label);
striplabel2 = gtk_label_new (buf);
gtk_widget_ref (striplabel2);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "striplabel2", striplabel2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (striplabel2);
gtk_box_pack_start (GTK_BOX (vbox1), striplabel2, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (striplabel2), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (striplabel2), 3, 0);
hbox2 = gtk_hbox_new (TRUE, 0);
gtk_widget_ref (hbox2);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "hbox2", hbox2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox1), hbox2, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 3);
#if 0
config_button = gtk_button_new_with_label ("Cfg");
gtk_widget_ref (config_button);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "config_button", config_button,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (config_button);
gtk_box_pack_start (GTK_BOX (hbox2), config_button, FALSE, FALSE, 0);
#endif
ps->ui_button = gtk_toggle_button_new_with_label ("UI");
gtk_widget_ref (ps->ui_button);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "ui_button", ps->ui_button,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (ps->ui_button);
gtk_box_pack_end (GTK_BOX (hbox2), ps->ui_button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (ps->ui_button), "toggled",
GTK_SIGNAL_FUNC (on_strip_ui_button_toggled),
(gpointer)ps);
gtk_signal_connect (GTK_OBJECT (ps->ui_button), "button_press_event",
GTK_SIGNAL_FUNC (on_strip_ui_button_event),
(gpointer)ps);
#if 0
ps->pan_adjustment = gtk_adjustment_new (48, 0, 100, 1, 10, 0);
hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (ps->pan_adjustment));
gtk_widget_ref (hscale1);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "hscale1", hscale1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hscale1);
gtk_box_pack_start (GTK_BOX (vbox1), hscale1, FALSE, FALSE, 0);
gtk_scale_set_digits (GTK_SCALE (hscale1), 0);
ps->level_adjustment = gtk_adjustment_new (-120, -120, 10, -1, -6, -1);
vscale1 = gtk_vscale_new (GTK_ADJUSTMENT (ps->level_adjustment));
gtk_widget_ref (vscale1);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "vscale1", vscale1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vscale1);
gtk_box_pack_start (GTK_BOX (vbox1), vscale1, TRUE, TRUE, 0);
#endif
return ps;
}
GtkWidget *a_uibuilder_new_widget ( VikLayerParam *param, VikLayerParamData data )
{
// Perform pre conversion if necessary
VikLayerParamData vlpd = data;
if ( param->convert_to_display )
vlpd = param->convert_to_display ( data );
GtkWidget *rv = NULL;
switch ( param->widget_type )
{
case VIK_LAYER_WIDGET_COLOR:
if ( param->type == VIK_LAYER_PARAM_COLOR )
rv = gtk_color_button_new_with_color ( &(vlpd.c) );
break;
case VIK_LAYER_WIDGET_CHECKBUTTON:
if ( param->type == VIK_LAYER_PARAM_BOOLEAN )
{
//rv = gtk_check_button_new_with_label ( //param->title );
rv = gtk_check_button_new ();
if ( vlpd.b )
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(rv), TRUE );
}
break;
case VIK_LAYER_WIDGET_COMBOBOX:
if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data )
{
/* Build a simple combobox */
gchar **pstr = param->widget_data;
rv = vik_combo_box_text_new ();
while ( *pstr )
vik_combo_box_text_append ( rv, *(pstr++) );
if ( param->extra_widget_data ) /* map of alternate uint values for options */
{
/* Set the effective default value */
int i;
for ( i = 0; ((const char **)param->widget_data)[i]; i++ )
if ( ((guint *)param->extra_widget_data)[i] == vlpd.u )
{
/* Match default value */
gtk_combo_box_set_active ( GTK_COMBO_BOX(rv), i );
break;
}
}
else
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), vlpd.u );
}
else if ( param->type == VIK_LAYER_PARAM_STRING && param->widget_data && !param->extra_widget_data )
{
/* Build a combobox with editable text */
gchar **pstr = param->widget_data;
#if GTK_CHECK_VERSION (2, 24, 0)
rv = gtk_combo_box_text_new_with_entry ();
#else
rv = gtk_combo_box_entry_new_text ();
#endif
if ( vlpd.s )
vik_combo_box_text_append ( rv, vlpd.s );
while ( *pstr )
vik_combo_box_text_append ( rv, *(pstr++) );
if ( vlpd.s )
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 );
}
else if ( param->type == VIK_LAYER_PARAM_STRING && param->widget_data && param->extra_widget_data)
{
/* Build a combobox with fixed selections without editable text */
gchar **pstr = param->widget_data;
rv = GTK_WIDGET ( vik_combo_box_text_new () );
while ( *pstr )
vik_combo_box_text_append ( rv, *(pstr++) );
if ( vlpd.s )
{
/* Set the effective default value */
/* In case of value does not exist, set the first value */
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 );
int i;
for ( i = 0; ((const char **)param->widget_data)[i]; i++ )
if ( strcmp(((const char **)param->extra_widget_data)[i], vlpd.s) == 0 )
{
/* Match default value */
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), i );
break;
}
}
else
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 );
}
break;
case VIK_LAYER_WIDGET_RADIOGROUP:
/* widget_data and extra_widget_data are GList */
if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data )
{
rv = vik_radio_group_new ( param->widget_data );
if ( param->extra_widget_data ) /* map of alternate uint values for options */
{
int i;
int nb_elem = g_list_length(param->widget_data);
for ( i = 0; i < nb_elem; i++ )
if ( GPOINTER_TO_UINT ( g_list_nth_data(param->extra_widget_data, i) ) == vlpd.u )
{
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), i );
break;
}
}
else if ( vlpd.u ) /* zero is already default */
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), vlpd.u );
}
break;
case VIK_LAYER_WIDGET_RADIOGROUP_STATIC:
if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data )
{
rv = vik_radio_group_new_static ( (const gchar **) param->widget_data );
if ( param->extra_widget_data ) /* map of alternate uint values for options */
{
int i;
for ( i = 0; ((const char **)param->widget_data)[i]; i++ )
if ( ((guint *)param->extra_widget_data)[i] == vlpd.u )
{
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), i );
break;
}
}
else if ( vlpd.u ) /* zero is already default */
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), vlpd.u );
}
break;
case VIK_LAYER_WIDGET_SPINBUTTON:
if ( (param->type == VIK_LAYER_PARAM_DOUBLE || param->type == VIK_LAYER_PARAM_UINT
|| param->type == VIK_LAYER_PARAM_INT) && param->widget_data )
{
gdouble init_val = (param->type == VIK_LAYER_PARAM_DOUBLE) ? vlpd.d : (param->type == VIK_LAYER_PARAM_UINT ? vlpd.u : vlpd.i);
VikLayerParamScale *scale = (VikLayerParamScale *) param->widget_data;
rv = gtk_spin_button_new ( GTK_ADJUSTMENT(gtk_adjustment_new( init_val, scale->min, scale->max, scale->step, scale->step, 0 )), scale->step, scale->digits );
}
break;
case VIK_LAYER_WIDGET_ENTRY:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = gtk_entry_new ();
if ( vlpd.s )
gtk_entry_set_text ( GTK_ENTRY(rv), vlpd.s );
}
break;
case VIK_LAYER_WIDGET_PASSWORD:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = gtk_entry_new ();
gtk_entry_set_visibility ( GTK_ENTRY(rv), FALSE );
if ( vlpd.s )
gtk_entry_set_text ( GTK_ENTRY(rv), vlpd.s );
gtk_widget_set_tooltip_text ( GTK_WIDGET(rv),
_("Take care that this password will be stored clearly in a plain file.") );
}
break;
case VIK_LAYER_WIDGET_FILEENTRY:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_OPEN, GPOINTER_TO_INT(param->widget_data), NULL, NULL);
if ( vlpd.s )
vik_file_entry_set_filename ( VIK_FILE_ENTRY(rv), vlpd.s );
}
break;
case VIK_LAYER_WIDGET_FOLDERENTRY:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, VF_FILTER_NONE, NULL, NULL);
if ( vlpd.s )
vik_file_entry_set_filename ( VIK_FILE_ENTRY(rv), vlpd.s );
}
break;
case VIK_LAYER_WIDGET_FILELIST:
if ( param->type == VIK_LAYER_PARAM_STRING_LIST )
{
rv = vik_file_list_new ( _(param->title), NULL );
vik_file_list_set_files ( VIK_FILE_LIST(rv), vlpd.sl );
}
break;
case VIK_LAYER_WIDGET_HSCALE:
if ( (param->type == VIK_LAYER_PARAM_DOUBLE || param->type == VIK_LAYER_PARAM_UINT
|| param->type == VIK_LAYER_PARAM_INT) && param->widget_data )
{
gdouble init_val = (param->type == VIK_LAYER_PARAM_DOUBLE) ? vlpd.d : (param->type == VIK_LAYER_PARAM_UINT ? vlpd.u : vlpd.i);
VikLayerParamScale *scale = (VikLayerParamScale *) param->widget_data;
rv = gtk_hscale_new_with_range ( scale->min, scale->max, scale->step );
gtk_scale_set_digits ( GTK_SCALE(rv), scale->digits );
gtk_range_set_value ( GTK_RANGE(rv), init_val );
}
case VIK_LAYER_WIDGET_BUTTON:
if ( param->type == VIK_LAYER_PARAM_PTR && param->widget_data ) {
rv = gtk_button_new_with_label ( param->widget_data );
g_signal_connect ( G_OBJECT(rv), "clicked", G_CALLBACK (vlpd.ptr), param->extra_widget_data );
}
break;
default: break;
}
if ( rv && !gtk_widget_get_tooltip_text ( rv ) ) {
if ( param->tooltip )
gtk_widget_set_tooltip_text ( rv, _(param->tooltip) );
}
return rv;
}
GtkWidget *
scale_create_widget (GtkWidget *dlg)
{
GtkWidget *w;
GtkObject *adj;
gint page;
if (options.scale_data.min_value >= options.scale_data.max_value)
{
g_printerr (_("Maximum value must be greater than minimum value.\n"));
return NULL;
}
/* check for initial value */
if (options.scale_data.have_value)
{
if (options.scale_data.value < options.scale_data.min_value)
{
g_printerr (_("Initial value less than minimal.\n"));
options.scale_data.value = options.scale_data.min_value;
}
else if (options.scale_data.value > options.scale_data.max_value)
{
g_printerr (_("Initial value greater than maximum.\n"));
options.scale_data.value = options.scale_data.max_value;
}
}
else
options.scale_data.value = options.scale_data.min_value;
page = options.scale_data.page == -1 ? options.scale_data.step * 10 : options.scale_data.page;
adj = gtk_adjustment_new ((double) options.scale_data.value,
(double) options.scale_data.min_value,
(double) options.scale_data.max_value,
(double) options.scale_data.step,
(double) page, 0.0);
if (options.scale_data.vertical)
{
w = scale = gtk_vscale_new (GTK_ADJUSTMENT (adj));
gtk_widget_set_name (w, "yad-vscale-widget");
gtk_range_set_inverted (GTK_RANGE (w), !options.scale_data.invert);
}
else
{
w = scale = gtk_hscale_new (GTK_ADJUSTMENT (adj));
gtk_widget_set_name (w, "yad-hscale-widget");
gtk_range_set_inverted (GTK_RANGE (w), options.scale_data.invert);
}
gtk_scale_set_digits (GTK_SCALE (w), 0);
if (options.scale_data.print_partial)
g_signal_connect (G_OBJECT (w), "value-changed",
G_CALLBACK (value_changed_cb), NULL);
if (options.scale_data.hide_value)
gtk_scale_set_draw_value (GTK_SCALE (w), FALSE);
/* add marks */
if (options.scale_data.marks)
{
GtkPositionType pos;
GSList *m = options.scale_data.marks;
pos = options.scale_data.vertical ? GTK_POS_LEFT : GTK_POS_BOTTOM;
for (; m; m = m->next)
{
YadScaleMark *mark = (YadScaleMark *) m->data;
gtk_scale_add_mark (GTK_SCALE (w), mark->value, pos, mark->name);
}
}
return w;
}
ConfigDialog *config_dialog_new(void)
{
ConfigDialog *config_win;
GtkTooltips *tooltips;
GtkWidget *window_main;
GtkWidget *vbox_main;
GtkWidget *label_scale_factor;
GtkWidget *hscale_scale_factor;
GtkWidget *frame_general;
GtkWidget *table_general;
GtkWidget *label_effect;
GtkWidget *label_palette;
GtkWidget *label_fps;
GtkWidget *checkbutton_show_title;
GtkWidget *hscale_effect;
GtkWidget *hscale_palette;
GtkObject *spinbutton_fps_adj;
GtkWidget *spinbutton_fps;
GtkWidget *hbuttonbox_main;
GtkWidget *button_ok;
GtkWidget *button_cancel;
GtkWidget *button_apply;
#if ENABLE_NLS
setlocale(LC_MESSAGES, "");
bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
textdomain(GETTEXT_PACKAGE);
#endif
window_main = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_object_set_data(GTK_OBJECT(window_main), "window_main", window_main);
gtk_window_set_title(GTK_WINDOW(window_main), _("Infinity Configuration"));
gtk_window_set_type_hint(GTK_WINDOW(window_main), GDK_WINDOW_TYPE_HINT_DIALOG);
vbox_main = gtk_vbox_new(FALSE, 0);
gtk_widget_ref(vbox_main);
gtk_object_set_data_full(GTK_OBJECT(window_main), "vbox_main", vbox_main,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(vbox_main);
gtk_container_add(GTK_CONTAINER(window_main), vbox_main);
gtk_container_set_border_width(GTK_CONTAINER(vbox_main), 2);
frame_general = gtk_frame_new(_("Parameters"));
gtk_widget_ref(frame_general);
gtk_object_set_data_full(GTK_OBJECT(window_main), "frame_general", frame_general,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(frame_general);
gtk_box_pack_start(GTK_BOX(vbox_main), frame_general, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame_general), 2);
table_general = gtk_table_new(5, 3, FALSE);
gtk_widget_ref(table_general);
gtk_object_set_data_full(GTK_OBJECT(window_main), "table_general", table_general,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(table_general);
gtk_container_add(GTK_CONTAINER(frame_general), table_general);
gtk_container_set_border_width(GTK_CONTAINER(table_general), 2);
gtk_table_set_row_spacings(GTK_TABLE(table_general), 2);
gtk_table_set_col_spacings(GTK_TABLE(table_general), 2);
label_effect = gtk_label_new(_("Effect period:"));
gtk_widget_ref(label_effect);
gtk_object_set_data_full(GTK_OBJECT(window_main), "label_effect", label_effect,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(label_effect);
gtk_table_attach(GTK_TABLE(table_general), label_effect, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_effect), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label_effect), 1, 0);
label_palette = gtk_label_new(_("Palette period:"));
gtk_widget_ref(label_palette);
gtk_object_set_data_full(GTK_OBJECT(window_main), "label_palette", label_palette,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(label_palette);
gtk_table_attach(GTK_TABLE(table_general), label_palette, 0, 1, 1, 2,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_palette), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label_palette), 1, 0);
label_scale_factor = gtk_label_new(_("Scale Factor"));
gtk_widget_ref(label_scale_factor);
gtk_object_set_data_full(GTK_OBJECT(window_main), "label_scale_factor", label_scale_factor,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(label_scale_factor);
gtk_table_attach(GTK_TABLE(table_general), label_scale_factor, 0, 1, 2, 3,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_scale_factor), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label_scale_factor), 1, 0);
label_fps = gtk_label_new(_("Maximum Frames per Second:"));
gtk_widget_ref(label_fps);
gtk_object_set_data_full(GTK_OBJECT(window_main), "label_fps", label_fps,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(label_fps);
gtk_table_attach(GTK_TABLE(table_general), label_fps, 0, 1, 3, 4,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_fps), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label_fps), 1, 0);
checkbutton_show_title = gtk_check_button_new_with_label(_("Show current play title"));
gtk_widget_ref(checkbutton_show_title);
gtk_object_set_data_full(GTK_OBJECT(window_main), "checkbutton_show_title", checkbutton_show_title,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(checkbutton_show_title);
gtk_table_attach(GTK_TABLE(table_general), checkbutton_show_title, 0, 1, 4, 5,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
tooltips = gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips, checkbutton_show_title,
_("Check it if you want to see the current play "
"title on the Infinity's title bar"), NULL);
//spinbutton_fps_adj = gtk_adjustment_new (30, 5, 150, 1, 10, 0);
spinbutton_fps_adj = gtk_adjustment_new(config_get_fps(), 5, 150, 1, 10, 0);
spinbutton_fps = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_fps_adj), 1, 0);
gtk_widget_ref(spinbutton_fps);
gtk_object_set_data_full(GTK_OBJECT(window_main), "spinbutton_fps", spinbutton_fps,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(spinbutton_fps);
gtk_table_attach(GTK_TABLE(table_general), spinbutton_fps, 2, 3, 3, 4,
(GtkAttachOptions)(0),
(GtkAttachOptions)(0), 0, 0);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spinbutton_fps), GTK_UPDATE_IF_VALID);
hscale_effect = gtk_hscale_new(GTK_ADJUSTMENT(gtk_adjustment_new(100, 50, 400, 0, 0, 0)));
gtk_widget_ref(hscale_effect);
gtk_object_set_data_full(GTK_OBJECT(window_main), "hscale_effect", hscale_effect,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(hscale_effect);
gtk_table_attach(GTK_TABLE(table_general), hscale_effect, 1, 3, 0, 1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_scale_set_value_pos(GTK_SCALE(hscale_effect), GTK_POS_LEFT);
gtk_scale_set_digits(GTK_SCALE(hscale_effect), 0);
gtk_tooltips_set_tip(tooltips, hscale_effect,
_("Time to change between an effect and the "
"next one, in milliseconds."), NULL);
hscale_palette = gtk_hscale_new(GTK_ADJUSTMENT(gtk_adjustment_new(100, 50, 400, 0, 0, 0)));
gtk_widget_ref(hscale_palette);
gtk_object_set_data_full(GTK_OBJECT(window_main), "hscale_palette", hscale_palette,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(hscale_palette);
gtk_table_attach(GTK_TABLE(table_general), hscale_palette, 1, 3, 1, 2,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_scale_set_value_pos(GTK_SCALE(hscale_palette), GTK_POS_LEFT);
gtk_scale_set_digits(GTK_SCALE(hscale_palette), 0);
gtk_tooltips_set_tip(tooltips, hscale_palette,
_("Time to change between a color and the "
"next one, in milliseconds."), NULL);
hscale_scale_factor = gtk_hscale_new(GTK_ADJUSTMENT(gtk_adjustment_new(1, 1, 2, 0, 0, 0)));
gtk_widget_ref(hscale_scale_factor);
gtk_object_set_data_full(GTK_OBJECT(window_main), "hscale_scale_factor", hscale_scale_factor,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(hscale_scale_factor);
gtk_table_attach(GTK_TABLE(table_general), hscale_scale_factor, 1, 3, 2, 3,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_scale_set_value_pos(GTK_SCALE(hscale_scale_factor), GTK_POS_LEFT);
gtk_scale_set_digits(GTK_SCALE(hscale_scale_factor), 0);
gtk_tooltips_set_tip(tooltips, hscale_scale_factor,
_("Change only if the system doesn't have "
"enough power to show the screen at "
"a reasonably speed/size relation."), NULL);
hbuttonbox_main = gtk_hbutton_box_new();
gtk_widget_ref(hbuttonbox_main);
gtk_object_set_data_full(GTK_OBJECT(window_main), "hbuttonbox_main", hbuttonbox_main,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(hbuttonbox_main);
gtk_box_pack_start(GTK_BOX(vbox_main), hbuttonbox_main, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbuttonbox_main), 2);
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox_main), GTK_BUTTONBOX_END);
button_ok = gtk_button_new_with_label(_("Ok"));
gtk_widget_ref(button_ok);
gtk_object_set_data_full(GTK_OBJECT(window_main), "button_ok", button_ok,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(button_ok);
gtk_container_add(GTK_CONTAINER(hbuttonbox_main), button_ok);
GTK_WIDGET_SET_FLAGS(button_ok, GTK_CAN_DEFAULT);
gtk_tooltips_set_tip(tooltips, button_ok,
_("For to toggle to fullscreen mode, select "
"the Infinity plugin window, and press "
"the Tab key. Pressing Tab again will return "
"to window mode."), NULL);
button_cancel = gtk_button_new_with_label(_("Cancel"));
gtk_widget_ref(button_cancel);
gtk_object_set_data_full(GTK_OBJECT(window_main), "button_cancel", button_cancel,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(button_cancel);
gtk_container_add(GTK_CONTAINER(hbuttonbox_main), button_cancel);
GTK_WIDGET_SET_FLAGS(button_cancel, GTK_CAN_DEFAULT);
button_apply = gtk_button_new_with_label(_("Apply"));
gtk_widget_ref(button_apply);
gtk_object_set_data_full(GTK_OBJECT(window_main), "button_apply", button_apply,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(button_apply);
gtk_container_add(GTK_CONTAINER(hbuttonbox_main), button_apply);
GTK_WIDGET_SET_FLAGS(button_apply, GTK_CAN_DEFAULT);
gtk_widget_grab_default(button_cancel);
config_win = g_new0(ConfigDialog, 1);
config_win->window_main = window_main;
config_win->hscale_effect = hscale_effect;
config_win->hscale_palette = hscale_palette;
config_win->hscale_scale_factor = hscale_scale_factor;
config_win->spinbutton_fps = spinbutton_fps;
config_win->checkbutton_show_title = checkbutton_show_title;
config_win->button_ok = button_ok;
config_win->button_cancel = button_cancel;
config_win->button_apply = button_apply;
gtk_tooltips_enable(tooltips);
return config_win;
}
cartesianMover::cartesianMover(GtkWidget *vbox_d, PolyDriver *partDd_d, char *partName, ResourceFinder *fnd)
{
finder = fnd;
if (!finder->isNull())
fprintf(stderr, "Setting a valid finder \n");
partLabel = partName;
partDd = partDd_d;
vbox = vbox_d;
interfaceError = false;
if (!partDd->isValid()) {
fprintf(stderr, "Device given to the cartesian interface is not available.\n");
interfaceError = true;
}
fprintf(stderr, "Opening crt interface...");
bool ok;
ok = partDd->view(crt);
if ((!ok) || (crt==0))
fprintf(stderr, "...crt was not ok...ok=%d", ok);
if (!partDd->isValid()) {
fprintf(stderr, "Cartesian device driver was not valid! \n");
dialog_severe_error(GTK_MESSAGE_ERROR,(char *) "Cartesian device not available.", (char *) "Check available devices", true);
interfaceError = true;
}
else if (!ok) {
fprintf(stderr, "Error while acquiring cartesian interfaces \n");
dialog_severe_error(GTK_MESSAGE_ERROR,(char *) "Problems acquiring cartesian interface", (char *) "Check if cartesian interface is running", true);
interfaceError = true;
}
if (interfaceError == false)
{
fprintf(stderr, "Allocating memory \n");
int j,k;
index = new int [MAX_NUMBER_OF_JOINTS];
entry_id = new guint [0];
*entry_id = -1;
frame_slider1 = new GtkWidget* [MAX_NUMBER_OF_JOINTS];
sliderArray = new GtkWidget* [NUMBER_OF_CARTESIAN_COORDINATES];
currPosArray = new GtkWidget* [NUMBER_OF_CARTESIAN_COORDINATES];
//fprintf(stderr, "sliderArray has address 0x%x\n", (unsigned int) sliderArray);
GtkWidget *top_hbox = NULL;
GtkWidget *bottom_hbox = NULL;
GtkWidget *panel_hbox = NULL;
GtkWidget *inv1 = NULL;
GtkWidget *invArray[NUMBER_OF_CARTESIAN_COORDINATES];
GtkWidget *homeArray[NUMBER_OF_CARTESIAN_COORDINATES];
GtkWidget *framesArray[NUMBER_OF_CARTESIAN_COORDINATES];
GtkWidget *sw = NULL;
//creation of the top_hbox
top_hbox = gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (top_hbox), 10);
gtk_container_add (GTK_CONTAINER (vbox), top_hbox);
inv1 = gtk_fixed_new ();
gtk_container_add (GTK_CONTAINER (top_hbox), inv1);
Vector o;
Vector x;
while (!crt->getPose(x,o))
Time::delay(0.001);
Matrix R = axis2dcm(o);
Vector eu = dcm2euler(R);
//x(0) = 1; x(1) = 1; x(2) = 1;
//o(0) = 1; o(1) = 0; o(2) = 0; o(3) = 0;
char buffer[40] = {'i', 'n', 'i', 't'};
int numberOfRows = 3;
int height, width;
height = 100;
width = 180;
double min,max;
std::string limitString=partLabel;
limitString=limitString+"_workspace";
Bottle bCartesianLimits;
if (finder->check(limitString.c_str()))
{
//fprintf(stderr, "There seem limits for %s", partLabel);
bCartesianLimits = finder->findGroup(limitString.c_str());
//fprintf(stderr, "...got: %s", bCartesianLimits.toString().c_str());
}
fprintf(stderr, "Starting embedding cartesian GUI widgets \n");
for (k = 0; k<NUMBER_OF_CARTESIAN_COORDINATES; k++)
{
//fprintf(stderr, "Adding invArray \n");
invArray[k] = gtk_fixed_new ();
index[k]=k;
j = k/numberOfRows;
if (k==0)
{
sprintf(buffer, "x");
if (bCartesianLimits.check("xmin") && bCartesianLimits.check("xmax"))
{
min = bCartesianLimits.find("xmin").asDouble();
max = bCartesianLimits.find("xmax").asDouble();
}
else
{
min = x(0) - 0.1 * fabs(x(0));
max = x(0) + 0.1 * fabs(x(0));
}
}
if (k==1)
{
sprintf(buffer, "y");
if (bCartesianLimits.check("ymin") && bCartesianLimits.check("ymax"))
{
min = bCartesianLimits.find("ymin").asDouble();
max = bCartesianLimits.find("ymax").asDouble();
}
else
{
min = x(1) - 0.1 * fabs(x(1));
max = x(1) + 0.1 * fabs(x(1));
}
}
if (k==2)
{
sprintf(buffer, "z");
if (bCartesianLimits.check("zmin") && bCartesianLimits.check("zmax"))
{
min = bCartesianLimits.find("zmin").asDouble();
max = bCartesianLimits.find("zmax").asDouble();
}
else
{
min = x(2) - 0.1 * fabs(x(2));
max = x(2) + 0.1 * fabs(x(2));
}
}
if (k==3)
{
sprintf(buffer, "euler-alpha");
min = -180;
max = 180;
}
if (k==4)
{
sprintf(buffer, "euler-beta");
min = -180;
max = 180;
}
if (k==5)
{
sprintf(buffer, "euler-gamma");
min = -180;
max = 180;
}
frame_slider1[k] = gtk_frame_new ("Value:");
//fprintf(stderr, "Initializing sliders %d \n",k);
if (min<max)
{
sliderArray[k] = gtk_hscale_new_with_range(min, max, 1);
if (k<3)
gtk_scale_set_digits((GtkScale*) sliderArray[k],2);
else
gtk_scale_set_digits((GtkScale*) sliderArray[k],1);
}
else
{
sliderArray[k] = gtk_hscale_new_with_range(1, 2, 1);
if (k<3)
gtk_scale_set_digits((GtkScale*) sliderArray[k],2);
else
gtk_scale_set_digits((GtkScale*) sliderArray[k],1);
}
currPosArray[k] = gtk_entry_new();
//fprintf(stderr, "Initializing the buttons %d \n", k);
homeArray[k] = gtk_button_new_with_mnemonic ("Home");
//fprintf(stderr, "Initializing frames %d \n", k);
framesArray[k] = gtk_frame_new (buffer);
gtk_fixed_put (GTK_FIXED(inv1), invArray[k], 0+(k%numberOfRows)*width, 0+ j*height);
//Positions
//fprintf(stderr, "Positioning buttons %d \n", k);
gtk_fixed_put (GTK_FIXED(invArray[k]), frame_slider1[k], 60, 10 );
gtk_fixed_put (GTK_FIXED(invArray[k]), sliderArray[k], 65, 20 );
gtk_fixed_put (GTK_FIXED(invArray[k]), currPosArray[k], 95, 70);
int buttonDist= 24;
int buttonOffset = 13;
gtk_fixed_put (GTK_FIXED(invArray[k]), homeArray[k], 6, buttonOffset);
gtk_fixed_put (GTK_FIXED(invArray[k]), framesArray[k], 0, 0);
//Dimensions
//fprintf(stderr, "Dimensioning buttons %d \n", k);
gtk_widget_set_size_request (frame_slider1[k], 110, 50);
gtk_widget_set_size_request (sliderArray[k], 90, 40);
gtk_widget_set_size_request (currPosArray[k], 70, 20);
gtk_widget_set_size_request (homeArray[k], 50, 25);
gtk_widget_set_size_request (framesArray[k], width, height);
/*
* Positions commands
*/
//fprintf(stderr, "Assinging callback %d \n", k);
gtk_range_set_update_policy ((GtkRange *) (sliderArray[k]), GTK_UPDATE_DISCONTINUOUS);
if (k<3)
gtk_range_set_value ((GtkRange *) (sliderArray[k]), x(k));
if (k>=3 && k <= 5)
gtk_range_set_value ((GtkRange *) (sliderArray[k]), eu(k-3) * 180/M_PI);
g_signal_connect (sliderArray[k], "value-changed", G_CALLBACK(position_slider_changed), this);
}
/*
* Display current position
*/
*entry_id = gtk_timeout_add(UPDATE_TIME, (GtkFunction) display_cartesian_pose, this);
for (k = 0; k<NUMBER_OF_CARTESIAN_COORDINATES; k++)
gtk_editable_set_editable ((GtkEditable*) currPosArray[k], FALSE);
/*
* Common commands
*/
GtkWidget *frame3;
frame3 = gtk_frame_new ("Commands:");
gtk_fixed_put (GTK_FIXED(inv1), frame3, (NUMBER_OF_CARTESIAN_COORDINATES%numberOfRows)*width, (NUMBER_OF_CARTESIAN_COORDINATES/numberOfRows)*height);
gtk_widget_set_size_request (frame3, 180, 240);
//Button 0 in the panel
GtkWidget *button0 = gtk_button_new_with_mnemonic ("Open sequence tab");
gtk_fixed_put (GTK_FIXED (inv1), button0, 10+(NUMBER_OF_CARTESIAN_COORDINATES%numberOfRows)*width, 20+(NUMBER_OF_CARTESIAN_COORDINATES/numberOfRows)*height);
gtk_widget_set_size_request (button0, 150, 25);
fprintf(stderr, "Initializing the table \n");
init_cartesian_table();
fprintf(stderr, "Connecting the callbacks for the table \n");
g_signal_connect (button0, "clicked", G_CALLBACK (cartesian_table_open), this);
//Button1 in the panel
GtkWidget *button1 = gtk_button_new_with_mnemonic ("Stop");
gtk_fixed_put (GTK_FIXED (inv1), button1, 10+(NUMBER_OF_CARTESIAN_COORDINATES%numberOfRows)*width, 45+(NUMBER_OF_CARTESIAN_COORDINATES/numberOfRows)*height);
gtk_widget_set_size_request (button1, 150, 25);
//g_signal_connect (button1, "clicked", G_CALLBACK (stop_motion), crt);
//Velocity
GtkWidget *frame7;
frame7 = gtk_frame_new ("Time[sec]:");
gtk_fixed_put (GTK_FIXED(inv1), frame7, 5+(NUMBER_OF_CARTESIAN_COORDINATES%numberOfRows)*width, 70 + (NUMBER_OF_CARTESIAN_COORDINATES/numberOfRows)*height);
gtk_widget_set_size_request (frame7, 160, 50);
sliderVelocity = new GtkWidget;
sliderVelocity = gtk_hscale_new_with_range(1, 10, 1);
gtk_scale_set_digits((GtkScale*) sliderVelocity,2);
gtk_fixed_put (GTK_FIXED(inv1), sliderVelocity, 60+(NUMBER_OF_CARTESIAN_COORDINATES%numberOfRows)*width, 80 + (NUMBER_OF_CARTESIAN_COORDINATES/numberOfRows)*height);
gtk_widget_set_size_request (sliderVelocity, 90, 40);
gtk_range_set_update_policy ((GtkRange *) (sliderVelocity), GTK_UPDATE_DISCONTINUOUS);
gtk_range_set_value ((GtkRange *) (sliderVelocity), 2);
//Diplay axis
po = new GtkWidget*[4];
for (int i=0; i < 4; i++)
{
po[i] = gtk_entry_new();
}
//Display axis
GtkWidget *frame5;
frame5 = gtk_frame_new ("Axis:");
gtk_fixed_put (GTK_FIXED(inv1), frame5, 5+(NUMBER_OF_CARTESIAN_COORDINATES%numberOfRows)*width, 140 + (NUMBER_OF_CARTESIAN_COORDINATES/numberOfRows)*height);
gtk_widget_set_size_request (frame5, 80, 85);
gtk_fixed_put (GTK_FIXED(inv1), po[0], 10+(NUMBER_OF_CARTESIAN_COORDINATES%numberOfRows)*width, 155+(NUMBER_OF_CARTESIAN_COORDINATES/numberOfRows)*height);
gtk_fixed_put (GTK_FIXED(inv1), po[1], 10+(NUMBER_OF_CARTESIAN_COORDINATES%numberOfRows)*width, 175+(NUMBER_OF_CARTESIAN_COORDINATES/numberOfRows)*height);
gtk_fixed_put (GTK_FIXED(inv1), po[2], 10+(NUMBER_OF_CARTESIAN_COORDINATES%numberOfRows)*width, 195+(NUMBER_OF_CARTESIAN_COORDINATES/numberOfRows)*height);
//Display angle
GtkWidget *frame6;
frame6 = gtk_frame_new ("Angle:");
gtk_fixed_put (GTK_FIXED(inv1), frame6, 85+(NUMBER_OF_CARTESIAN_COORDINATES%numberOfRows)*width, 155 + (NUMBER_OF_CARTESIAN_COORDINATES/numberOfRows)*height);
gtk_widget_set_size_request (frame6, 80, 45);
gtk_fixed_put (GTK_FIXED(inv1), po[3], 90+(NUMBER_OF_CARTESIAN_COORDINATES%numberOfRows)*width, 175+(NUMBER_OF_CARTESIAN_COORDINATES/numberOfRows)*height);
for (int i=0; i < 4; i++)
{
gtk_widget_set_size_request (po[i], 70, 20);
gtk_editable_set_editable ((GtkEditable*) po[i], FALSE);
}
*entry_id = gtk_timeout_add(UPDATE_TIME, (GtkFunction) display_axis_pose, this);
//CheckButton in the panel
GtkWidget *check= gtk_check_button_new_with_mnemonic ("Tracking Mode");
gtk_fixed_put (GTK_FIXED (inv1), check, 10+(NUMBER_OF_CARTESIAN_COORDINATES%numberOfRows)*width, 120+(NUMBER_OF_CARTESIAN_COORDINATES/numberOfRows)*height);
gtk_widget_set_size_request (check, 150, 25);
//g_signal_connect (check, "clicked", G_CALLBACK (toggle_tracking_mode), crt);
}
}
GtkWidget*
create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *Horizontal;
GtkWidget *Vertical;
GtkWidget *Dering;
GtkWidget *vbox2;
GtkWidget *SwapUV;
GtkWidget *alignment1;
GtkWidget *hbox1;
GtkWidget *image1;
GtkWidget *label2;
GtkWidget *label1;
GtkWidget *hscale1;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), _("Mplayer PostProc options"));
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
Horizontal = gtk_check_button_new_with_mnemonic (_("Horizontal Deblocking"));
gtk_widget_show (Horizontal);
gtk_box_pack_start (GTK_BOX (vbox1), Horizontal, FALSE, FALSE, 0);
Vertical = gtk_check_button_new_with_mnemonic (_("Vertical Deblocking"));
gtk_widget_show (Vertical);
gtk_box_pack_start (GTK_BOX (vbox1), Vertical, FALSE, FALSE, 0);
Dering = gtk_check_button_new_with_mnemonic (_("Deringing"));
gtk_widget_show (Dering);
gtk_box_pack_start (GTK_BOX (vbox1), Dering, FALSE, FALSE, 0);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0);
SwapUV = gtk_check_button_new ();
gtk_widget_show (SwapUV);
gtk_box_pack_start (GTK_BOX (vbox2), SwapUV, FALSE, FALSE, 0);
alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (alignment1);
gtk_container_add (GTK_CONTAINER (SwapUV), alignment1);
hbox1 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox1);
gtk_container_add (GTK_CONTAINER (alignment1), hbox1);
image1 = gtk_image_new_from_stock ("gtk-refresh", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image1);
gtk_box_pack_start (GTK_BOX (hbox1), image1, FALSE, FALSE, 0);
label2 = gtk_label_new_with_mnemonic (_("Swap U & V"));
gtk_widget_show (label2);
gtk_box_pack_start (GTK_BOX (hbox1), label2, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
label1 = gtk_label_new (_("Filter Strength"));
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT);
hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (5, 0, 5, 1, 1, 0)));
gtk_widget_show (hscale1);
gtk_box_pack_start (GTK_BOX (vbox1), hscale1, TRUE, TRUE, 0);
gtk_scale_set_digits (GTK_SCALE (hscale1), 0);
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (dialog1, Horizontal, "Horizontal");
GLADE_HOOKUP_OBJECT (dialog1, Vertical, "Vertical");
GLADE_HOOKUP_OBJECT (dialog1, Dering, "Dering");
GLADE_HOOKUP_OBJECT (dialog1, vbox2, "vbox2");
GLADE_HOOKUP_OBJECT (dialog1, SwapUV, "SwapUV");
GLADE_HOOKUP_OBJECT (dialog1, alignment1, "alignment1");
GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (dialog1, image1, "image1");
GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
static void
rejilla_song_control_init (RejillaSongControl *object)
{
RejillaSongControlPrivate *priv;
GtkWidget *alignment;
GtkWidget *volume;
gint volume_value;
GtkWidget *image;
GtkWidget *vbox;
GtkWidget *hbox;
gpointer value;
GstBus *bus;
priv = REJILLA_SONG_CONTROL_PRIVATE (object);
/* Pipeline */
priv->pipe = gst_element_factory_make ("playbin2", NULL);
if (priv->pipe) {
GstElement *audio_sink;
audio_sink = gst_element_factory_make ("mateconfaudiosink", NULL);
if (audio_sink)
g_object_set (G_OBJECT (priv->pipe),
"audio-sink", audio_sink,
NULL);
}
else
g_warning ("Pipe creation error : can't create pipe.\n");
bus = gst_pipeline_get_bus (GST_PIPELINE (priv->pipe));
gst_bus_add_watch (bus,
(GstBusFunc) rejilla_song_control_bus_messages,
object);
gst_object_unref (bus);
/* Widget itself */
vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 0);
gtk_container_add (GTK_CONTAINER (object), vbox);
/* first line title */
hbox = gtk_hbox_new (FALSE, 12);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox),
hbox,
FALSE,
FALSE,
0);
priv->header = gtk_label_new (_("No file"));
gtk_widget_show (priv->header);
gtk_label_set_use_markup (GTK_LABEL (priv->header), TRUE);
gtk_label_set_justify (GTK_LABEL (priv->header), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (priv->header), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox),
priv->header,
TRUE,
TRUE,
0);
priv->size = gtk_label_new (NULL);
gtk_widget_show (priv->size);
gtk_label_set_justify (GTK_LABEL (priv->size), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (priv->size), 0.0, 0.0);
gtk_box_pack_end (GTK_BOX (hbox),
priv->size,
FALSE,
FALSE,
0);
/* second line : play, progress, volume button */
hbox = gtk_hbox_new (FALSE, 12);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox),
hbox,
FALSE,
FALSE,
0);
alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
gtk_widget_show (alignment);
priv->button = gtk_toggle_button_new ();
gtk_widget_show (priv->button);
gtk_widget_set_tooltip_text (priv->button, _("Start and stop playing"));
gtk_container_add (GTK_CONTAINER (alignment), priv->button);
gtk_box_pack_start (GTK_BOX (hbox),
alignment,
FALSE,
FALSE,
0);
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (priv->button), image);
g_signal_connect (G_OBJECT (priv->button), "clicked",
G_CALLBACK (rejilla_song_control_button_clicked_cb),
object);
priv->progress = gtk_hscale_new_with_range (0, 1, 500000000);
gtk_widget_show (priv->progress);
gtk_scale_set_digits (GTK_SCALE (priv->progress), 0);
gtk_scale_set_draw_value (GTK_SCALE (priv->progress), FALSE);
gtk_widget_set_size_request (priv->progress, 80, -1);
gtk_range_set_update_policy (GTK_RANGE (priv->progress), GTK_UPDATE_CONTINUOUS);
gtk_box_pack_start (GTK_BOX (hbox),
priv->progress,
TRUE,
TRUE,
0);
g_signal_connect (G_OBJECT (priv->progress),
"button-press-event",
G_CALLBACK (rejilla_song_control_range_button_pressed_cb), object);
g_signal_connect (G_OBJECT (priv->progress),
"button-release-event",
G_CALLBACK (rejilla_song_control_range_button_released_cb), object);
g_signal_connect (G_OBJECT (priv->progress),
"value-changed",
G_CALLBACK (rejilla_song_control_range_value_changed),
object);
/* Set saved volume */
rejilla_setting_get_value (rejilla_setting_get_default (),
REJILLA_SETTING_PLAYER_VOLUME,
&value);
volume_value = GPOINTER_TO_INT (value);
volume_value = CLAMP (volume_value, 0, 100);
g_object_set (priv->pipe,
"volume", (gdouble) volume_value / 100.0,
NULL);
volume = gtk_volume_button_new ();
gtk_widget_show (volume);
gtk_box_pack_start (GTK_BOX (hbox),
volume,
FALSE,
FALSE,
0);
gtk_scale_button_set_value (GTK_SCALE_BUTTON (volume), (gdouble) volume_value / 100.0);
g_signal_connect (volume,
"value-changed",
G_CALLBACK (rejilla_song_control_volume_changed_cb),
object);
gtk_alignment_set_padding (GTK_ALIGNMENT (object), 12, 0, 0, 0);
}
/* Here the fist page of the layout is created */
void create_encoding_layout(GtkWidget *table)
{
GtkWidget *preview_button, *label, *addnorm_button;
GtkWidget *bicubic_button, *player_field, *saveonexit_button;
GtkObject *adjust_scale, *adjust_scale_n;
int table_line;
table_line = 0;
t_use_yuvplay_pipe = use_yuvplay_pipe;
t_addoutputnorm = encoding.addoutputnorm;
t_use_bicubic = use_bicubic;
t_fourpelmotion = fourpelmotion;
t_twopelmotion = twopelmotion;
sprintf(t_selected_player, "%s", selected_player);
t_saveonexit = saveonexit;
label = gtk_label_new ("Save the encoding options when exiting : ");
gtk_table_attach_defaults (GTK_TABLE (table),
label, 0, 1, table_line, table_line+1);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, GTK_MISC(label)->yalign);
gtk_widget_show (label);
saveonexit_button = gtk_check_button_new();
gtk_widget_ref (saveonexit_button);
if (saveonexit != 0)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (saveonexit_button), TRUE);
gtk_signal_connect (GTK_OBJECT (saveonexit_button), "toggled",
GTK_SIGNAL_FUNC (set_saveonexit), NULL );
gtk_table_attach_defaults (GTK_TABLE (table),
saveonexit_button, 1, 2, table_line, table_line+1);
gtk_widget_show (saveonexit_button);
table_line++;
label = gtk_label_new ("Show video while encoding : ");
gtk_table_attach_defaults (GTK_TABLE (table),
label, 0, 1, table_line, table_line+1);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, GTK_MISC(label)->yalign);
gtk_widget_show (label);
preview_button = gtk_check_button_new();
gtk_widget_ref (preview_button);
if (use_yuvplay_pipe)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (preview_button), TRUE);
gtk_signal_connect (GTK_OBJECT (preview_button), "toggled",
GTK_SIGNAL_FUNC (set_encoding_preview), NULL );
gtk_table_attach_defaults (GTK_TABLE (table),
preview_button, 1, 2, table_line, table_line+1);
gtk_widget_show (preview_button);
table_line++;
label = gtk_label_new ("Add norm when using yuvscaler : ");
gtk_table_attach_defaults (GTK_TABLE (table),
label, 0, 1, table_line, table_line+1);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, GTK_MISC(label)->yalign);
gtk_widget_show (label);
addnorm_button = gtk_check_button_new();
gtk_widget_ref (addnorm_button);
if (encoding.addoutputnorm)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (addnorm_button), TRUE);
gtk_signal_connect (GTK_OBJECT (addnorm_button), "toggled",
GTK_SIGNAL_FUNC (set_addoutputnorm), NULL );
gtk_table_attach_defaults (GTK_TABLE (table),
addnorm_button, 1, 2, table_line, table_line+1);
gtk_widget_show (addnorm_button);
table_line++;
label = gtk_label_new ("Always use bicubic for scaling : ");
gtk_table_attach_defaults (GTK_TABLE (table),
label, 0, 1, table_line, table_line+1);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, GTK_MISC(label)->yalign);
gtk_widget_show (label);
bicubic_button = gtk_check_button_new();
// gtk_widget_ref (bicubic_button);
if (use_bicubic) /* <- Does the preset of the values -v */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (bicubic_button), TRUE);
gtk_signal_connect (GTK_OBJECT (bicubic_button), "toggled",
GTK_SIGNAL_FUNC (set_bicubicuse), NULL );
gtk_table_attach_defaults (GTK_TABLE (table),
bicubic_button, 1, 2, table_line, table_line+1);
gtk_widget_show (bicubic_button);
table_line++;
label = gtk_label_new (" 4*4-pel subsampled motion comp : ");
gtk_table_attach_defaults (GTK_TABLE (table),
label, 0, 1, table_line, table_line+1);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, GTK_MISC(label)->yalign);
gtk_widget_show (label);
adjust_scale = gtk_adjustment_new (1.0, 1.0, 5.0, 1, 1.0, 1.0);
fourpel_scale = gtk_hscale_new (GTK_ADJUSTMENT (adjust_scale));
gtk_scale_set_value_pos (GTK_SCALE(fourpel_scale), GTK_POS_LEFT);
gtk_scale_set_digits (GTK_SCALE (fourpel_scale),0);
gtk_signal_connect (GTK_OBJECT (adjust_scale), "value_changed",
GTK_SIGNAL_FUNC (change_four), adjust_scale);
gtk_table_attach_defaults (GTK_TABLE (table),
fourpel_scale, 1, 2, table_line, table_line+1);
gtk_widget_show (fourpel_scale);
gtk_adjustment_set_value (GTK_ADJUSTMENT (adjust_scale), t_fourpelmotion);
table_line++;
label = gtk_label_new (" 2*2-pel subsampled motion comp : ");
gtk_table_attach_defaults (GTK_TABLE (table),
label, 0, 1, table_line, table_line+1);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, GTK_MISC(label)->yalign);
gtk_widget_show (label);
adjust_scale_n = gtk_adjustment_new (1.0, 1.0, 5.0, 1, 1.0, 1.0);
twopel_scale = gtk_hscale_new (GTK_ADJUSTMENT (adjust_scale_n));
gtk_scale_set_value_pos (GTK_SCALE(twopel_scale), GTK_POS_LEFT);
gtk_scale_set_digits (GTK_SCALE (twopel_scale),0);
gtk_signal_connect (GTK_OBJECT (adjust_scale_n), "value_changed",
GTK_SIGNAL_FUNC (change_two), adjust_scale_n);
gtk_table_attach_defaults (GTK_TABLE (table),
twopel_scale, 1, 2, table_line, table_line+1);
gtk_widget_show (twopel_scale);
gtk_adjustment_set_value (GTK_ADJUSTMENT (adjust_scale_n), t_twopelmotion);
table_line++;
label = gtk_label_new (" Player and options for playback : ");
gtk_table_attach_defaults (GTK_TABLE (table),
label, 0, 1, table_line, table_line+1);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, GTK_MISC(label)->yalign);
gtk_widget_show (label);
player_field = gtk_entry_new ();
gtk_entry_set_text(GTK_ENTRY(player_field), selected_player);
gtk_signal_connect(GTK_OBJECT(player_field), "changed",
GTK_SIGNAL_FUNC(player_callback), player_field);
gtk_table_attach_defaults (GTK_TABLE (table),
player_field, 1, 2, table_line, table_line+1);
gtk_widget_show (player_field);
}
int
main (int argc, char **argv)
{
GtkWidget *window, *hbox, *vbox, *play_button, *pause_button, *stop_button;
GstBus *bus;
GOptionEntry options[] = {
{"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
"Verbose properties", NULL},
{NULL}
};
gint type;
GOptionContext *ctx;
GError *err = NULL;
if (!g_thread_supported ())
g_thread_init (NULL);
ctx = g_option_context_new ("seek");
g_option_context_add_main_entries (ctx, options, NULL);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing: %s\n", err->message);
exit (1);
}
GST_DEBUG_CATEGORY_INIT (scrubby_debug, "scrubby", 0, "scrubby example");
gtk_init (&argc, &argv);
if (argc != 3) {
print_usage (argc, argv);
exit (-1);
}
type = atoi (argv[1]);
if (type < 0 || type >= NUM_TYPES) {
print_usage (argc, argv);
exit (-1);
}
pipeline = pipelines[type].func (argv[2]);
g_assert (pipeline);
/* initialize gui elements ... */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
hbox = gtk_hbox_new (FALSE, 0);
vbox = gtk_vbox_new (FALSE, 0);
play_button = gtk_button_new_with_label ("play");
pause_button = gtk_button_new_with_label ("pause");
stop_button = gtk_button_new_with_label ("stop");
adjustment =
GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, (gdouble) RANGE_PREC, 0.1,
1.0, 1.0));
hscale = gtk_hscale_new (adjustment);
gtk_scale_set_digits (GTK_SCALE (hscale), 2);
gtk_range_set_update_policy (GTK_RANGE (hscale), GTK_UPDATE_CONTINUOUS);
sadjustment =
GTK_ADJUSTMENT (gtk_adjustment_new (1.0, 0.0, 5.0, 0.1, 1.0, 0.0));
shscale = gtk_hscale_new (sadjustment);
gtk_scale_set_digits (GTK_SCALE (shscale), 2);
gtk_range_set_update_policy (GTK_RANGE (shscale), GTK_UPDATE_CONTINUOUS);
schanged_id = gtk_signal_connect (GTK_OBJECT (shscale),
"value_changed", G_CALLBACK (speed_cb), pipeline);
gtk_signal_connect (GTK_OBJECT (hscale),
"button_press_event", G_CALLBACK (start_seek), pipeline);
gtk_signal_connect (GTK_OBJECT (hscale),
"button_release_event", G_CALLBACK (stop_seek), pipeline);
gtk_signal_connect (GTK_OBJECT (hscale),
"format_value", G_CALLBACK (format_value), pipeline);
/* do the packing stuff ... */
gtk_window_set_default_size (GTK_WINDOW (window), 96, 96);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_container_add (GTK_CONTAINER (vbox), hbox);
gtk_box_pack_start (GTK_BOX (hbox), play_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (hbox), pause_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (hbox), stop_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (vbox), hscale, TRUE, TRUE, 2);
gtk_box_pack_start (GTK_BOX (vbox), shscale, TRUE, TRUE, 2);
/* connect things ... */
g_signal_connect (G_OBJECT (play_button), "clicked", G_CALLBACK (play_cb),
pipeline);
g_signal_connect (G_OBJECT (pause_button), "clicked", G_CALLBACK (pause_cb),
pipeline);
g_signal_connect (G_OBJECT (stop_button), "clicked", G_CALLBACK (stop_cb),
pipeline);
g_signal_connect (G_OBJECT (window), "delete_event", gtk_main_quit, NULL);
/* show the gui. */
gtk_widget_show_all (window);
if (verbose) {
g_signal_connect (pipeline, "deep_notify",
G_CALLBACK (gst_object_default_deep_notify), NULL);
}
bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
g_assert (bus);
bus_watch = gst_bus_add_watch_full (bus,
G_PRIORITY_HIGH, bus_message, pipeline, NULL);
gtk_main ();
g_print ("NULL pipeline\n");
gst_element_set_state (pipeline, GST_STATE_NULL);
g_print ("free pipeline\n");
gst_object_unref (pipeline);
return 0;
}
static void configure()
{
GtkWidget *notebook1;
GtkWidget *vbox;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *Resolution_Frame;
GtkWidget *vbox4;
GSList *resolution_group = NULL;
GtkWidget *Channels_Frame;
GtkWidget *vbox5;
GSList *vbox5_group = NULL;
GtkWidget *Downsample_Frame;
GtkWidget *vbox3;
GSList *sample_group = NULL;
GtkWidget *vbox6;
GtkWidget *Quality_Label;
GtkWidget *Options_Label;
GtkWidget *pansep_label, *pansep_hscale;
GtkWidget *bbox;
GtkWidget *ok;
GtkWidget *cancel;
if (xmp_conf_window) {
gdk_window_raise(xmp_conf_window->window);
return;
}
xmp_conf_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_object_set_data(GTK_OBJECT(xmp_conf_window),
"xmp_conf_window", xmp_conf_window);
gtk_window_set_title(GTK_WINDOW(xmp_conf_window), "XMP Configuration");
gtk_window_set_policy(GTK_WINDOW(xmp_conf_window), FALSE, FALSE, FALSE);
gtk_window_set_position(GTK_WINDOW(xmp_conf_window), GTK_WIN_POS_MOUSE);
gtk_signal_connect(GTK_OBJECT(xmp_conf_window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),&xmp_conf_window);
gtk_container_border_width(GTK_CONTAINER(xmp_conf_window), 10);
vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(xmp_conf_window), vbox);
notebook1 = gtk_notebook_new();
gtk_object_set_data(GTK_OBJECT(xmp_conf_window),"notebook1", notebook1);
gtk_widget_show(notebook1);
gtk_box_pack_start(GTK_BOX(vbox), notebook1, TRUE, TRUE, 0);
gtk_container_border_width(GTK_CONTAINER(notebook1), 3);
vbox1 = gtk_vbox_new(FALSE, 0);
gtk_object_set_data(GTK_OBJECT(xmp_conf_window),"vbox1", vbox1);
gtk_widget_show(vbox1);
hbox1 = gtk_hbox_new(FALSE, 0);
gtk_object_set_data(GTK_OBJECT(xmp_conf_window),"hbox1", hbox1);
gtk_widget_show(hbox1);
gtk_box_pack_start(GTK_BOX(vbox1), hbox1, TRUE, TRUE, 0);
Resolution_Frame = gtk_frame_new("Resolution");
gtk_object_set_data(GTK_OBJECT(xmp_conf_window),
"Resolution_Frame", Resolution_Frame);
gtk_widget_show(Resolution_Frame);
gtk_box_pack_start(GTK_BOX(hbox1), Resolution_Frame, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER (Resolution_Frame), 5);
vbox4 = gtk_vbox_new(FALSE, 0);
gtk_object_set_data(GTK_OBJECT(xmp_conf_window),"vbox4", vbox4);
gtk_widget_show(vbox4);
gtk_container_add(GTK_CONTAINER(Resolution_Frame), vbox4);
Res_16 = gtk_radio_button_new_with_label(resolution_group, "16 bit");
resolution_group = gtk_radio_button_group(GTK_RADIO_BUTTON(Res_16));
gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "Res_16", Res_16);
gtk_widget_show(Res_16);
gtk_box_pack_start(GTK_BOX(vbox4), Res_16, TRUE, TRUE, 0);
if (xmp_cfg.force8bit == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(Res_16), TRUE);
Res_8 = gtk_radio_button_new_with_label(resolution_group, "8 bit");
resolution_group = gtk_radio_button_group(GTK_RADIO_BUTTON(Res_8));
gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "Res_8", Res_8);
gtk_widget_show(Res_8);
gtk_box_pack_start(GTK_BOX(vbox4), Res_8, TRUE, TRUE, 0);
if (xmp_cfg.force8bit == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(Res_8), TRUE);
Channels_Frame = gtk_frame_new("Channels");
gtk_object_set_data(GTK_OBJECT(xmp_conf_window),
"Channels_Frame", Channels_Frame);
gtk_widget_show(Channels_Frame);
gtk_box_pack_start(GTK_BOX(hbox1), Channels_Frame, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(Channels_Frame), 5);
vbox5 = gtk_vbox_new(FALSE, 0);
gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "vbox5", vbox5);
gtk_widget_show(vbox5);
gtk_container_add(GTK_CONTAINER(Channels_Frame), vbox5);
Chan_ST = gtk_radio_button_new_with_label(vbox5_group, "Stereo");
vbox5_group = gtk_radio_button_group(GTK_RADIO_BUTTON(Chan_ST));
gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "Chan_ST", Chan_ST);
gtk_widget_show(Chan_ST);
gtk_box_pack_start(GTK_BOX(vbox5), Chan_ST, TRUE, TRUE, 0);
if (xmp_cfg.force_mono == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(Chan_ST), TRUE);
Chan_MO = gtk_radio_button_new_with_label(vbox5_group, "Mono");
vbox5_group = gtk_radio_button_group(GTK_RADIO_BUTTON(Chan_MO));
gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "Chan_MO", Chan_MO);
gtk_widget_show(Chan_MO);
gtk_box_pack_start(GTK_BOX(vbox5), Chan_MO, TRUE, TRUE, 0);
if (xmp_cfg.force_mono == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(Chan_MO), TRUE);
Downsample_Frame = gtk_frame_new("Sampling rate");
gtk_object_set_data(GTK_OBJECT(xmp_conf_window),
"Downsample_Frame", Downsample_Frame);
gtk_widget_show(Downsample_Frame);
gtk_box_pack_start(GTK_BOX(vbox1), Downsample_Frame, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(Downsample_Frame), 5);
vbox3 = gtk_vbox_new(FALSE, 0);
gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "vbox3", vbox3);
gtk_widget_show(vbox3);
gtk_container_add(GTK_CONTAINER(Downsample_Frame), vbox3);
Sample_44 = gtk_radio_button_new_with_label(sample_group, "44 kHz");
sample_group = gtk_radio_button_group(GTK_RADIO_BUTTON(Sample_44));
gtk_object_set_data(GTK_OBJECT(xmp_conf_window),"Sample_44", Sample_44);
gtk_widget_show(Sample_44);
gtk_box_pack_start(GTK_BOX(vbox3), Sample_44, TRUE, TRUE, 0);
if (xmp_cfg.mixing_freq == FREQ_SAMPLE_44)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(Sample_44),TRUE);
Sample_22 = gtk_radio_button_new_with_label(sample_group, "22 kHz");
sample_group = gtk_radio_button_group(GTK_RADIO_BUTTON(Sample_22));
gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "Sample_22",Sample_22);
gtk_widget_show(Sample_22);
gtk_box_pack_start(GTK_BOX(vbox3), Sample_22, TRUE, TRUE, 0);
if (xmp_cfg.mixing_freq == FREQ_SAMPLE_22)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(Sample_22),TRUE);
Sample_11 = gtk_radio_button_new_with_label(sample_group, "11 kHz");
sample_group = gtk_radio_button_group(GTK_RADIO_BUTTON(Sample_11));
gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "Sample_11",Sample_11);
gtk_widget_show(Sample_11);
gtk_box_pack_start(GTK_BOX(vbox3), Sample_11, TRUE, TRUE, 0);
if (xmp_cfg.mixing_freq == FREQ_SAMPLE_11)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(Sample_11),TRUE);
vbox6 = gtk_vbox_new(FALSE, 0);
gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "vbox6", vbox6);
gtk_widget_show(vbox6);
/* Options */
#define OPTCHECK(w,l,o) { \
w = gtk_check_button_new_with_label(l); \
gtk_object_set_data(GTK_OBJECT(xmp_conf_window), #w, w); \
gtk_widget_show(w); \
gtk_box_pack_start(GTK_BOX(vbox6), w, TRUE, TRUE, 0); \
if (xmp_cfg.o == 1) \
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), TRUE); \
}
OPTCHECK(Convert_Check, "Convert 16 bit samples to 8 bit", convert8bit);
OPTCHECK(Fixloops_Check, "Fix sample loops", fixloops);
OPTCHECK(Modrange_Check, "Force 3 octave range in standard MOD files",
modrange);
OPTCHECK(Interp_Check, "Enable 32-bit linear interpolation",
interpolation);
OPTCHECK(Filter_Check, "Enable IT filters", filter);
pansep_label = gtk_label_new("Pan amplitude (%)");
gtk_widget_show(pansep_label);
gtk_box_pack_start(GTK_BOX(vbox6), pansep_label, TRUE, TRUE, 0);
pansep_adj = gtk_adjustment_new(xmp_cfg.pan_amplitude,
0.0, 100.0, 1.0, 10.0, 1.0);
pansep_hscale = gtk_hscale_new(GTK_ADJUSTMENT(pansep_adj));
gtk_scale_set_digits(GTK_SCALE(pansep_hscale), 0);
gtk_scale_set_draw_value(GTK_SCALE(pansep_hscale), TRUE);
gtk_scale_set_value_pos(GTK_SCALE(pansep_hscale), GTK_POS_BOTTOM);
gtk_widget_show(pansep_hscale);
gtk_box_pack_start(GTK_BOX(vbox6), pansep_hscale, TRUE, TRUE, 0);
Quality_Label = gtk_label_new("Quality");
gtk_object_set_data(GTK_OBJECT(xmp_conf_window),
"Quality_Label", Quality_Label);
gtk_widget_show(Quality_Label);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook1), vbox1, Quality_Label);
Options_Label = gtk_label_new("Options");
gtk_object_set_data(GTK_OBJECT(xmp_conf_window),
"Options_Label", Options_Label);
gtk_widget_show(Options_Label);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook1), vbox6, Options_Label);
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
ok = gtk_button_new_with_label("Ok");
gtk_signal_connect(GTK_OBJECT(ok), "clicked",
GTK_SIGNAL_FUNC(config_ok), NULL);
GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0);
gtk_widget_show(ok);
gtk_widget_grab_default(ok);
cancel = gtk_button_new_with_label("Cancel");
gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(xmp_conf_window));
GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);
gtk_widget_show(cancel);
gtk_widget_show(bbox);
gtk_widget_show(vbox);
gtk_widget_show(xmp_conf_window);
}
void
procdialog_create_renice_dialog (ProcData *procdata)
{
ProcInfo *info = procdata->selected_process;
GtkWidget *dialog = NULL;
GtkWidget *dialog_vbox;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *priority_label;
GtkWidget *grid;
GtkAdjustment *renice_adj;
GtkWidget *hscale;
GtkWidget *button;
GtkWidget *icon;
gchar *text;
gchar *dialog_title;
if (renice_dialog)
return;
if (!info)
return;
dialog_title = g_strdup_printf (_("Change Priority of Process “%s” (PID: %u)"),
info->name, info->pid);
dialog = gtk_dialog_new_with_buttons (dialog_title, NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
"gtk-cancel", GTK_RESPONSE_CANCEL,
NULL);
g_free (dialog_title);
renice_dialog = dialog;
gtk_window_set_resizable (GTK_WINDOW (renice_dialog), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (renice_dialog), 5);
button = gtk_button_new_with_mnemonic (_("Change _Priority"));
gtk_widget_set_can_default (button, TRUE);
icon = gtk_image_new_from_stock ("gtk-ok", GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (button), icon);
gtk_dialog_add_action_widget (GTK_DIALOG (renice_dialog), button, 100);
gtk_dialog_set_default_response (GTK_DIALOG (renice_dialog), 100);
new_nice_value = -100;
dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_box_set_spacing (GTK_BOX (dialog_vbox), 2);
gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_box_pack_start (GTK_BOX (dialog_vbox), vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID(grid), 12);
gtk_grid_set_row_spacing (GTK_GRID(grid), 6);
gtk_box_pack_start (GTK_BOX (vbox), grid, TRUE, TRUE, 0);
label = gtk_label_new_with_mnemonic (_("_Nice value:"));
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 2);
renice_adj = gtk_adjustment_new (info->nice, RENICE_VAL_MIN, RENICE_VAL_MAX, 1, 1, 0);
new_nice_value = 0;
hscale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, renice_adj);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), hscale);
gtk_scale_set_digits (GTK_SCALE (hscale), 0);
gtk_widget_set_hexpand (hscale, TRUE);
gtk_grid_attach (GTK_GRID (grid), hscale, 1, 0, 1, 1);
text = g_strdup_printf(_("(%s Priority)"), procman::get_nice_level (info->nice));
priority_label = gtk_label_new (text);
gtk_grid_attach (GTK_GRID (grid), priority_label, 1, 1, 1, 1);
g_free(text);
text = g_strconcat("<small><i><b>", _("Note:"), "</b> ",
_("The priority of a process is given by its nice value. A lower nice value corresponds to a higher priority."),
"</i></small>", NULL);
label = gtk_label_new (_(text));
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
g_free (text);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (renice_dialog_button_pressed), procdata);
g_signal_connect (G_OBJECT (renice_adj), "value_changed",
G_CALLBACK (renice_scale_changed), priority_label);
gtk_widget_show_all (dialog);
}
GtkWidget*
create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *frame1;
GtkWidget *table2;
GtkWidget *label4;
GtkWidget *label5;
GtkWidget *hscaleBrightness;
GtkWidget *hscaleSaturation;
GtkWidget *hscaleContrast;
GtkWidget *label3;
GtkWidget *label1;
GtkWidget *frame2;
GtkWidget *table3;
GtkWidget *label6;
GtkWidget *hscaleGamma;
GtkWidget *hscaleGammaR;
GtkWidget *label8;
GtkWidget *hscaleGammaG;
GtkWidget *label9;
GtkWidget *label10;
GtkWidget *label7;
GtkWidget *hscaleGammaB;
GtkWidget *hscaleGammaWeight;
GtkWidget *label2;
GtkWidget *hscale1;
GtkWidget *drawingarea1;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_container_set_border_width (GTK_CONTAINER (dialog1), 6);
gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("MPlayer eq2"));
gtk_window_set_resizable (GTK_WINDOW (dialog1), FALSE);
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (hbox1), frame1, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_NONE);
table2 = gtk_table_new (3, 2, FALSE);
gtk_widget_show (table2);
gtk_container_add (GTK_CONTAINER (frame1), table2);
gtk_container_set_border_width (GTK_CONTAINER (table2), 12);
gtk_table_set_row_spacings (GTK_TABLE (table2), 6);
gtk_table_set_col_spacings (GTK_TABLE (table2), 12);
label4 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Brigh_tness:"));
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table2), label4, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
label5 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Saturation:"));
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table2), label5, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
hscaleBrightness = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, -1, 1, 0.05, 1, 0)));
gtk_widget_show (hscaleBrightness);
gtk_table_attach (GTK_TABLE (table2), hscaleBrightness, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleBrightness, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleBrightness), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleBrightness), 2);
hscaleSaturation = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 3, 0.05, 1, 0)));
gtk_widget_show (hscaleSaturation);
gtk_table_attach (GTK_TABLE (table2), hscaleSaturation, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleSaturation, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleSaturation), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleSaturation), 2);
hscaleContrast = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, -2, 2, 0.05, 1, 0)));
gtk_widget_show (hscaleContrast);
gtk_table_attach (GTK_TABLE (table2), hscaleContrast, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleContrast, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleContrast), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleContrast), 2);
label3 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Contrast:"));
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table2), label3, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
label1 = gtk_label_new ("");
gtk_widget_show (label1);
gtk_frame_set_label_widget (GTK_FRAME (frame1), label1);
gtk_label_set_use_markup (GTK_LABEL (label1), TRUE);
gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT);
frame2 = gtk_frame_new (NULL);
gtk_widget_show (frame2);
gtk_box_pack_start (GTK_BOX (hbox1), frame2, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_NONE);
table3 = gtk_table_new (5, 2, FALSE);
gtk_widget_show (table3);
gtk_container_add (GTK_CONTAINER (frame2), table3);
gtk_container_set_border_width (GTK_CONTAINER (table3), 12);
gtk_table_set_row_spacings (GTK_TABLE (table3), 6);
gtk_table_set_col_spacings (GTK_TABLE (table3), 12);
label6 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Initial:"));
gtk_widget_show (label6);
gtk_table_attach (GTK_TABLE (table3), label6, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5);
hscaleGamma = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0)));
gtk_widget_show (hscaleGamma);
gtk_table_attach (GTK_TABLE (table3), hscaleGamma, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleGamma, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleGamma), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleGamma), 2);
hscaleGammaR = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0)));
gtk_widget_show (hscaleGammaR);
gtk_table_attach (GTK_TABLE (table3), hscaleGammaR, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleGammaR, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaR), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleGammaR), 2);
label8 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Red:"));
gtk_widget_show (label8);
gtk_table_attach (GTK_TABLE (table3), label8, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label8), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5);
hscaleGammaG = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0)));
gtk_widget_show (hscaleGammaG);
gtk_table_attach (GTK_TABLE (table3), hscaleGammaG, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleGammaG, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaG), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleGammaG), 2);
label9 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Green:"));
gtk_widget_show (label9);
gtk_table_attach (GTK_TABLE (table3), label9, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label9), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5);
label10 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Blue:"));
gtk_widget_show (label10);
gtk_table_attach (GTK_TABLE (table3), label10, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label10), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label10), 0, 0.5);
label7 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Weight:"));
gtk_widget_show (label7);
gtk_table_attach (GTK_TABLE (table3), label7, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5);
hscaleGammaB = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0)));
gtk_widget_show (hscaleGammaB);
gtk_table_attach (GTK_TABLE (table3), hscaleGammaB, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleGammaB, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaB), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleGammaB), 2);
hscaleGammaWeight = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 1, 0.05, 1, 0)));
gtk_widget_show (hscaleGammaWeight);
gtk_table_attach (GTK_TABLE (table3), hscaleGammaWeight, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleGammaWeight, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaWeight), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleGammaWeight), 2);
label2 = gtk_label_new (QT_TR_NOOP("<b>Gamma</b>"));
gtk_widget_show (label2);
gtk_frame_set_label_widget (GTK_FRAME (frame2), label2);
gtk_label_set_use_markup (GTK_LABEL (label2), TRUE);
gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 1, 1, 0)));
gtk_widget_show (hscale1);
gtk_box_pack_start (GTK_BOX (vbox1), hscale1, FALSE, FALSE, 0);
drawingarea1 = gtk_drawing_area_new ();
gtk_widget_show (drawingarea1);
gtk_box_pack_start (GTK_BOX (vbox1), drawingarea1, TRUE, TRUE, 0);
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
gtk_label_set_mnemonic_widget (GTK_LABEL (label4), hscaleBrightness);
gtk_label_set_mnemonic_widget (GTK_LABEL (label5), hscaleSaturation);
gtk_label_set_mnemonic_widget (GTK_LABEL (label3), hscaleContrast);
gtk_label_set_mnemonic_widget (GTK_LABEL (label6), hscaleGamma);
gtk_label_set_mnemonic_widget (GTK_LABEL (label8), hscaleGammaR);
gtk_label_set_mnemonic_widget (GTK_LABEL (label9), hscaleGammaG);
gtk_label_set_mnemonic_widget (GTK_LABEL (label10), hscaleGammaB);
gtk_label_set_mnemonic_widget (GTK_LABEL (label7), hscaleGammaWeight);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (dialog1, frame1, "frame1");
GLADE_HOOKUP_OBJECT (dialog1, table2, "table2");
GLADE_HOOKUP_OBJECT (dialog1, label4, "label4");
GLADE_HOOKUP_OBJECT (dialog1, label5, "label5");
GLADE_HOOKUP_OBJECT (dialog1, hscaleBrightness, "hscaleBrightness");
GLADE_HOOKUP_OBJECT (dialog1, hscaleSaturation, "hscaleSaturation");
GLADE_HOOKUP_OBJECT (dialog1, hscaleContrast, "hscaleContrast");
GLADE_HOOKUP_OBJECT (dialog1, label3, "label3");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, frame2, "frame2");
GLADE_HOOKUP_OBJECT (dialog1, table3, "table3");
GLADE_HOOKUP_OBJECT (dialog1, label6, "label6");
GLADE_HOOKUP_OBJECT (dialog1, hscaleGamma, "hscaleGamma");
GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaR, "hscaleGammaR");
GLADE_HOOKUP_OBJECT (dialog1, label8, "label8");
GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaG, "hscaleGammaG");
GLADE_HOOKUP_OBJECT (dialog1, label9, "label9");
GLADE_HOOKUP_OBJECT (dialog1, label10, "label10");
GLADE_HOOKUP_OBJECT (dialog1, label7, "label7");
GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaB, "hscaleGammaB");
GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaWeight, "hscaleGammaWeight");
GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1");
GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
static void ctrl_create(GtkWidget *vbox)
{
GtkWidget *hbox, *c_lab, *c_val, *c_reset;
struct v4l2_queryctrl qctrl = { V4L2_CTRL_FLAG_NEXT_CTRL };
struct v4l2_control ctrl;
struct v4l2_jpegcompression jc;
struct v4l2_streamparm parm;
long id;
int setval;
while (ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0) {
//test
//fprintf(stderr, "%32.32s type:%d flags:0x%04x\n", qctrl.name, qctrl.type, qctrl.flags);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
c_lab = gtk_label_new(strdup((char *) qctrl.name));
gtk_widget_set_size_request(GTK_WIDGET(c_lab), 160, -1);
gtk_box_pack_start(GTK_BOX(hbox), c_lab, FALSE, FALSE, 0);
setval = 1;
switch (qctrl.type) {
case V4L2_CTRL_TYPE_INTEGER:
case V4L2_CTRL_TYPE_MENU:
c_val = gtk_hscale_new_with_range(qctrl.minimum,
qctrl.maximum,
qctrl.step);
gtk_scale_set_value_pos(GTK_SCALE(c_val), GTK_POS_LEFT);
// gtk_scale_set_value_pos(GTK_SCALE(c_val), GTK_POS_RIGHT);
gtk_scale_set_draw_value(GTK_SCALE(c_val), TRUE);
gtk_scale_set_digits(GTK_SCALE(c_val), 0);
gtk_range_set_update_policy(GTK_RANGE(c_val), GTK_UPDATE_DELAYED);
break;
case V4L2_CTRL_TYPE_BOOLEAN:
c_val = gtk_check_button_new();
break;
default:
c_val = gtk_label_new(strdup("(not treated yet"));
setval = 0;
break;
}
gtk_widget_set_size_request(GTK_WIDGET(c_val), 300, -1);
gtk_box_pack_start(GTK_BOX(hbox), c_val, FALSE, FALSE, 0);
if (setval) {
id = qctrl.id;
ctrl.id = id;
if (ioctl(fd, VIDIOC_G_CTRL, &ctrl) < 0)
fprintf(stderr, "get control error %d, %s\n",
errno, strerror(errno));
switch (qctrl.type) {
case V4L2_CTRL_TYPE_INTEGER:
case V4L2_CTRL_TYPE_MENU:
gtk_range_set_value(GTK_RANGE(c_val), ctrl.value);
g_signal_connect(G_OBJECT(c_val), "value_changed",
G_CALLBACK(set_ctrl), (gpointer) id);
break;
case V4L2_CTRL_TYPE_BOOLEAN:
//test
//fprintf(stderr, "button: %08x %d\n", ctrl.id, ctrl.value);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(c_val),
ctrl.value);
g_signal_connect(G_OBJECT(c_val), "toggled",
G_CALLBACK(toggle_ctrl), (gpointer) id);
break;
default:
break;
}
c_reset = gtk_button_new_with_label("Reset");
gtk_box_pack_start(GTK_BOX(hbox), c_reset, FALSE, FALSE, 40);
gtk_widget_set_size_request(GTK_WIDGET(c_reset), 60, 20);
g_signal_connect(G_OBJECT(c_reset), "released",
G_CALLBACK(reset_ctrl), (gpointer) id);
if (qctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
gtk_widget_set_sensitive(c_val, FALSE);
gtk_widget_set_sensitive(c_reset, FALSE);
}
}
qctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
}
/* JPEG quality */
if (ioctl(fd, VIDIOC_G_JPEGCOMP, &jc) >= 0) {
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
c_lab = gtk_label_new("JPEG quality");
gtk_widget_set_size_request(GTK_WIDGET(c_lab), 150, -1);
gtk_box_pack_start(GTK_BOX(hbox), c_lab, FALSE, FALSE, 0);
c_val = gtk_hscale_new_with_range(20, 99, 1);
gtk_scale_set_draw_value(GTK_SCALE(c_val), TRUE);
gtk_scale_set_digits(GTK_SCALE(c_val), 0);
gtk_widget_set_size_request(GTK_WIDGET(c_val), 300, -1);
gtk_range_set_value(GTK_RANGE(c_val), jc.quality);
gtk_box_pack_start(GTK_BOX(hbox), c_val, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(c_val), "value_changed",
G_CALLBACK(set_qual), (gpointer) NULL);
#if 0
} else {
fprintf(stderr, "get jpeg quality error %d, %s\n",
errno, strerror(errno));
#endif
}
/* framerate */
memset(&parm, 0, sizeof parm);
parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (ioctl(fd, VIDIOC_G_PARM, &parm) >= 0) {
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
c_lab = gtk_label_new("Frame rate");
gtk_widget_set_size_request(GTK_WIDGET(c_lab), 150, -1);
gtk_box_pack_start(GTK_BOX(hbox), c_lab, FALSE, FALSE, 0);
c_val = gtk_hscale_new_with_range(5, 120, 1);
gtk_scale_set_draw_value(GTK_SCALE(c_val), TRUE);
gtk_scale_set_digits(GTK_SCALE(c_val), 0);
gtk_widget_set_size_request(GTK_WIDGET(c_val), 300, -1);
gtk_range_set_value(GTK_RANGE(c_val),
parm.parm.capture.timeperframe.denominator);
gtk_box_pack_start(GTK_BOX(hbox), c_val, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(c_val), "value_changed",
G_CALLBACK(set_parm), (gpointer) NULL);
#if 0
} else {
fprintf(stderr, "get frame rate error %d, %s\n",
errno, strerror(errno));
#endif
}
}
/**
* scale_entry_new:
* @table: The #GtkTable the widgets will be attached to.
* @column: The column to start with.
* @row: The row to attach the widgets.
* @text: The text for the #GtkLabel which will appear
* left of the #GtkHScale.
* @scale_usize: The minimum horizontal size of the #GtkHScale.
* @spinbutton_usize: The minimum horizontal size of the #GtkSpinButton.
* @value: The initial value.
* @lower: The lower boundary.
* @upper: The upper boundary.
* @step_increment: The step increment.
* @page_increment: The page increment.
* @digits: The number of decimal digits.
* @constrain: #TRUE if the range of possible values of the
* #GtkSpinButton should be the same as of the #GtkHScale.
* @unconstrained_lower: The spinbutton's lower boundary
* if @constrain == #FALSE.
* @unconstrained_upper: The spinbutton's upper boundary
* if @constrain == #FALSE.
* @tooltip: A tooltip message for the scale and the spinbutton.
*
* This function creates a #GtkLabel, a #GtkHScale and a #GtkSpinButton and
* attaches them to a 3-column #GtkTable.
*
* Returns: The #GtkSpinButton's #GtkAdjustment.
**/
GtkObject *
stpui_scale_entry_new(GtkTable *table,
gint column,
gint row,
const gchar *text,
gint scale_usize,
gint spinbutton_usize,
gfloat value,
gfloat lower,
gfloat upper,
gfloat step_increment,
gfloat page_increment,
guint digits,
gboolean constrain,
gfloat unconstrained_lower,
gfloat unconstrained_upper,
const gchar *tooltip)
{
GtkWidget *label;
GtkWidget *scale;
GtkWidget *spinbutton;
GtkObject *adjustment;
GtkObject *return_adj;
label = gtk_label_new (text);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
column + 1, column + 2, row, row + 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
if (! constrain &&
unconstrained_lower <= lower &&
unconstrained_upper >= upper)
{
GtkObject *constrained_adj;
constrained_adj = gtk_adjustment_new (value, lower, upper,
step_increment, page_increment,
0.0);
spinbutton = spin_button_new (&adjustment, value,
unconstrained_lower,
unconstrained_upper,
step_increment, page_increment, 0.0,
1.0, digits);
g_signal_connect
(G_OBJECT (constrained_adj), "value_changed",
G_CALLBACK (scale_entry_unconstrained_adjustment_callback),
adjustment);
g_signal_connect
(G_OBJECT (adjustment), "value_changed",
G_CALLBACK (scale_entry_unconstrained_adjustment_callback),
constrained_adj);
return_adj = adjustment;
adjustment = constrained_adj;
}
else
{
spinbutton = spin_button_new (&adjustment, value, lower, upper,
step_increment, page_increment, 0.0,
1.0, digits);
return_adj = adjustment;
}
if (spinbutton_usize > 0)
gtk_widget_set_usize (spinbutton, spinbutton_usize, -1);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
if (scale_usize > 0)
gtk_widget_set_usize (scale, scale_usize, -1);
gtk_scale_set_digits (GTK_SCALE (scale), digits);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_table_attach (GTK_TABLE (table), scale,
column + 2, column + 3, row, row + 1,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_show (scale);
gtk_table_attach (GTK_TABLE (table), spinbutton,
column + 3, column + 4, row, row + 1,
GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_widget_show (spinbutton);
if (tooltip)
{
stpui_set_help_data (scale, tooltip);
stpui_set_help_data (spinbutton, tooltip);
}
gtk_object_set_data (G_OBJECT (return_adj), "label", label);
gtk_object_set_data (G_OBJECT (return_adj), "scale", scale);
gtk_object_set_data (G_OBJECT (return_adj), "spinbutton", spinbutton);
return return_adj;
}
bool createch(void)
{
struct gchan *object;
GtkWidget *fixed;
GtkWidget *frami1;
GtkWidget *vbox, *htast, *hbot;
GtkObject *adj, *adj1;
GtkWidget *playmenu, *playmenuopt;
GtkWidget *tmpwid, *tmpwid1, *dock;
GtkWidget *progress;
GtkWidget *volume;
GtkWidget *scrollwin;
GtkWidget *table, *rmit/*, *file, *http*/;
GtkWidget *piddi;
GtkTreeSelection *select;
GtkListStore *store;
GtkWidget *tree;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTargetEntry target_entry[3];
gchar numchan[16];
unsigned int pos=0;
unsigned int idx=1;
dock=rmit=NULL;
while(( object = (struct gchan *) list_get_data(listachan, idx, 0) ))
idx++;
if(idx > MAX_CHANNELS)
return FALSE;
func(_("GTK_GUI::createch(%u)"), idx);
object = (struct gchan *) g_malloc (sizeof(struct gchan));
object->idx = idx;
object->channel = 0; /* nothing */
func(_("GTK_GUI::createch : chan[%u] is at %p"), idx, object);
mixer->create_channel(idx-1);
snprintf(numchan, 16, _("Channel[%u]"), object->idx);
frami1 = gtk_frame_new(numchan);
object->frami = frami1;
gtk_frame_set_shadow_type(GTK_FRAME(frami1), GTK_SHADOW_ETCHED_OUT);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frami1), vbox);
/* at the moment pos is 0 function */
list_add(&listachan, (void *) object, pos, idx, object->frami);
htast = gtk_hbox_new(TRUE, 0); /* same dimension */
fixed = gtk_fixed_new();
gtk_fixed_put(GTK_FIXED(fixed), htast, 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), fixed, FALSE, FALSE, 0);
/* addiamo il coso del tempo */
tmpwid = gtk_entry_new_with_max_length(9);
object->ptime = tmpwid;
gtk_widget_set_size_request(tmpwid, 55, 22);
gtk_entry_set_text(GTK_ENTRY(tmpwid), "00:00:00");
gtk_entry_set_editable(GTK_ENTRY(tmpwid), FALSE);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, FALSE, 0);
/* enjoy ourselves with buttons */
tmpwid = createpixmap(window, tmpwid, play_xpm,
_("Play Channel"), TRUE);
object->play = tmpwid;
g_signal_connect(G_OBJECT(tmpwid), "pressed",
G_CALLBACK(gcb_play_channel), object);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, TRUE, 0);
tmpwid = createpixmap(window, tmpwid, stop_xpm,
_("Stop Channel"), FALSE);
g_signal_connect(G_OBJECT(tmpwid), "pressed",
G_CALLBACK(gcb_stop_channel), object);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, TRUE, 0);
tmpwid = createpixmap(window, tmpwid, pause_xpm,
_("Pause Channel"), TRUE);
object->pause = tmpwid;
g_signal_connect(G_OBJECT(tmpwid), "clicked",
G_CALLBACK(gcb_pause_channel), object);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, TRUE, 0);
tmpwid = createpixmap(window, tmpwid, rewind_xpm,
_("Rewind Channel"), FALSE);
g_signal_connect(G_OBJECT(tmpwid), "clicked",
G_CALLBACK(gcb_begin_channel), object);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, TRUE, 0);
tmpwid = createpixmap(window, tmpwid, forward_xpm,
_("Forward Channel"), FALSE);
g_signal_connect(G_OBJECT(tmpwid), "clicked",
G_CALLBACK(gcb_end_channel), object);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, TRUE, 0);
/* second part */
adj = gtk_adjustment_new(0.0, 0.0, 1.0, 0.1, 0.1, 0.0);
object->adjprog = adj;
progress = gtk_hscale_new(GTK_ADJUSTMENT(adj));
gtk_range_set_update_policy(GTK_RANGE(progress),GTK_UPDATE_DELAYED);
gtk_scale_set_digits(GTK_SCALE(progress), 6);
object->progress = progress;
gtk_scale_set_draw_value(GTK_SCALE(progress), FALSE);
/*
g_signal_connect(G_OBJECT(progress), "button_press_event",
G_CALLBACK(gcb_event_pause_channel), object);
g_signal_connect(G_OBJECT(progress), "button_release_event",
G_CALLBACK(gcb_event_set_position), object);
*/
/* here there is a problem: the position sticks to the mouse
maybe there is a way to say to unfocus the widget after moving it? */
g_signal_connect(G_OBJECT(progress), "button_release_event",
G_CALLBACK(gcb_event_set_position), object);
gtk_box_pack_start(GTK_BOX(vbox), progress, FALSE, FALSE, 0);
hbot = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(vbox), hbot);
/* volume adjustment */
adj1 = gtk_adjustment_new(0.0, 0.0, 1.0, 0.01, 0.01, 0.0);
object->adjvol = adj1;
object->volid = g_signal_connect(G_OBJECT(adj1), "value_changed",
G_CALLBACK(gcb_set_volume), object);
#ifdef WITH_SPEED
/* speed adjustment */
object->adjspeed = gtk_adjustment_new(1.0, 0.0, 1.0, 0.1, 0.1, 0.0);
g_signal_connect(G_OBJECT(object->adjspeed), "value_changed",
G_CALLBACK(gcb_set_speed), object);
#endif
volume = gtk_vscale_new(GTK_ADJUSTMENT(adj1));
gtk_scale_set_draw_value(GTK_SCALE(volume), FALSE);
tmpwid = gtk_table_new(2, 1, FALSE);
gtk_box_pack_start(GTK_BOX(hbot), tmpwid, FALSE, FALSE, 0);
tmpwid1 = gtk_vbox_new(FALSE, 0);
object->vol_lab = gtk_label_new(_("VOL"));
gtk_box_pack_start(GTK_BOX(tmpwid1), object->vol_lab, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(tmpwid1), volume, TRUE, TRUE, 0);
object->vol_lab=gtk_label_new(_("100"));
gtk_box_pack_start(GTK_BOX(tmpwid1), object->vol_lab, FALSE, FALSE, 0);
gtk_table_attach_defaults(GTK_TABLE(tmpwid), tmpwid1, 0, 1, 1, 2);
#ifdef WITH_SPEED
/* speed widget */
// tmpwid1=gtk_vbox_new(FALSE, 0);
object->speed=gtk_tx_dial_new(GTK_ADJUSTMENT(object->adjspeed));
set_tip(object->speed, _("Speed"));
gtk_box_pack_start(GTK_BOX(tmpwid1), object->speed, FALSE, FALSE, 0);
object->speed_lab=gtk_label_new(_("100"));
gtk_box_pack_start(GTK_BOX(tmpwid1), object->speed_lab, FALSE, FALSE, 0);
gtk_table_attach_defaults(GTK_TABLE(tmpwid), tmpwid1, 0, 1, 0, 1);
#endif
scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_size_request(scrollwin, 90, 140);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
store = gtk_list_store_new(N_COLUMNS, G_TYPE_STRING);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
object->tree = tree;
//gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
/* DND stuff */
target_entry[0].target = (gchar *)DRAG_TAR_NAME_0;
target_entry[0].flags = 0;
target_entry[0].info = DRAG_TAR_INFO_0;
target_entry[1].target = (gchar *)DRAG_TAR_NAME_1;
target_entry[1].flags = 0;
target_entry[1].info = DRAG_TAR_INFO_1;
target_entry[2].target = (gchar *)DRAG_TAR_NAME_2;
target_entry[2].flags = 0;
target_entry[2].info = DRAG_TAR_INFO_2;
gtk_drag_dest_set(
tree,
(GtkDestDefaults)(GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT |
GTK_DEST_DEFAULT_DROP),
target_entry,sizeof(target_entry) / sizeof(GtkTargetEntry),
GDK_ACTION_MOVE);
g_signal_connect(G_OBJECT(tree), "drag_motion",
G_CALLBACK(DND_data_motion), object);
gtk_drag_source_set(
tree,
(GdkModifierType) (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK),
target_entry, sizeof(target_entry) / sizeof(GtkTargetEntry),
GDK_ACTION_MOVE);
g_signal_connect(G_OBJECT(tree), "drag_begin",
G_CALLBACK(DND_begin), object);
g_signal_connect(G_OBJECT(tree), "drag_end",
G_CALLBACK(DND_end), object);
g_signal_connect(G_OBJECT(tree), "drag_data_get",
G_CALLBACK(DND_data_get), object);
g_signal_connect(G_OBJECT(tree), "drag_data_received",
G_CALLBACK(DND_data_received), object);
g_signal_connect(G_OBJECT(tree), "drag_data_delete",
G_CALLBACK(DND_data_delete), object);
/* end*/
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
gtk_tree_selection_set_mode (select, GTK_SELECTION_MULTIPLE);
/*g_signal_connect(G_OBJECT(select), "changed",
G_CALLBACK(gcb_set_channel), object);
*/
g_signal_connect(G_OBJECT(tree), "button_press_event",
G_CALLBACK(gcb_event_view_popup), object);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Nick",
renderer, "text", TITLE, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
gtk_container_add(GTK_CONTAINER(scrollwin), tree);
gtk_box_pack_start(GTK_BOX(hbot), scrollwin, TRUE, TRUE, 0);
/* playmode menu */
playmenu = gtk_menu_new();
tmpwid = gtk_menu_item_new_with_label(_("single play"));
gtk_menu_append(GTK_MENU(playmenu), tmpwid);
tmpwid=gtk_menu_item_new_with_label(_("loop"));
gtk_menu_append(GTK_MENU(playmenu), tmpwid);
tmpwid=gtk_menu_item_new_with_label(_("continuous"));
gtk_menu_append(GTK_MENU(playmenu), tmpwid);
playmenuopt = gtk_option_menu_new();
gtk_option_menu_set_menu(GTK_OPTION_MENU(playmenuopt), playmenu);
g_signal_connect(G_OBJECT(playmenuopt), "changed",
G_CALLBACK(gcb_set_playmode), object);
rmit = gtk_button_new();
tmpwid = gtk_image_new_from_stock(GTK_STOCK_CANCEL,
GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_container_add(GTK_CONTAINER(rmit), tmpwid);
object->rmit = rmit;
g_signal_connect(G_OBJECT(object->rmit),"clicked",
G_CALLBACK(gcb_deletech), object);
dock = createpixmap(window, dock, dock_xpm,
_("Undock Channel"), FALSE);
object->dock = dock;
g_signal_connect(G_OBJECT(object->dock), "clicked",
G_CALLBACK(dockchan), object);
piddi = gtk_hbox_new(FALSE, 0);
object->hbox = piddi;
gtk_box_pack_start(GTK_BOX(piddi), rmit, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(piddi), dock, FALSE, FALSE, 0);
table = gtk_table_new(1, 4, TRUE);
object->table = table;
gtk_table_attach_defaults(GTK_TABLE(table), piddi, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table), playmenuopt, 3, 5, 0, 1);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
object->playmode = 0;
/* pack_chan_insert and pos update */
pos = pack_chan_insert(object->frami);
return TRUE;
}
extern void
GTKShowRolls(const gint nDepth, evalcontext * pec, matchstate * pms)
{
GtkWidget *vbox, *hbox, *vb2;
GtkAdjustment *padj;
int n;
rollswidget *prw = (rollswidget *) g_malloc(sizeof(rollswidget));
prw->closing = FALSE;
prw->pDialog = GTKCreateDialog(_("Distribution of rolls"), DT_INFO, NULL, DIALOG_FLAG_MODAL, NULL, NULL);
n = (nDepth < 1) ? 1 : nDepth;
prw->pms = pms;
prw->pec = pec;
prw->nDepth = -1; /* not yet calculated */
/* vbox to hold tree widget and buttons */
vbox = gtk_vbox_new(FALSE, 8);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
gtk_container_add(GTK_CONTAINER(DialogArea(prw->pDialog, DA_MAIN)), vbox);
/* hook to free rollswidget on widget destruction */
g_object_set_data_full(G_OBJECT(vbox), "rollswidget", prw, g_free);
/* scrolled window to hold tree widget */
prw->psw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(prw->psw), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(prw->psw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), prw->psw, TRUE, TRUE, 0);
/* buttons */
gtk_box_pack_start(GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 4);
gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new(_("Depth")), FALSE, FALSE, 4);
/* Set page size to 1 */
padj = GTK_ADJUSTMENT(gtk_adjustment_new(1., 1., 5., 1., 1., 0.));
prw->pScale = gtk_hscale_new(padj);
gtk_widget_set_size_request(prw->pScale, 100, -1);
gtk_box_pack_start(GTK_BOX(hbox), prw->pScale, FALSE, FALSE, 4);
gtk_scale_set_digits(GTK_SCALE(prw->pScale), 0);
gtk_scale_set_draw_value(GTK_SCALE(prw->pScale), TRUE);
/* Separate vbox to make button height correct */
vb2 = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vb2, FALSE, FALSE, 4);
prw->pCancel = gtk_button_new_with_label(_("Cancel"));
gtk_widget_set_size_request(prw->pCancel, -1, 27);
gtk_widget_set_sensitive(prw->pCancel, FALSE);
g_signal_connect(G_OBJECT(prw->pCancel), "clicked", G_CALLBACK(CancelRolls), NULL);
gtk_box_pack_start(GTK_BOX(vb2), prw->pCancel, FALSE, FALSE, 4);
g_signal_connect(G_OBJECT(prw->pScale), "button-press-event", G_CALLBACK(DepthEvent), prw);
g_signal_connect(G_OBJECT(prw->pScale), "button-release-event", G_CALLBACK(DepthEvent), prw);
g_signal_connect(G_OBJECT(prw->pScale), "value-changed", G_CALLBACK(DepthChanged), prw);
/* tree */
if ((prw->ptv = RollsTree(n, pec, pms)) != 0) {
gtk_container_add(GTK_CONTAINER(prw->psw), prw->ptv);
prw->nDepth = n;
}
gtk_window_set_default_size(GTK_WINDOW(prw->pDialog), 560, 400);
g_signal_connect(G_OBJECT(prw->pDialog), "delete_event", G_CALLBACK(RollsClose), prw); /* In case closed mid calculation */
GTKRunDialog(prw->pDialog);
}
void
Launch_Gtk_Process(int pipe_number)
{
int argc = 0;
gchar **argv = NULL;
GtkWidget *button, *mbar, *swin;
GtkWidget *table, *align, *handlebox;
GtkWidget *vbox, *hbox, *vbox2, *scrolled_win;
GtkObject *adj;
/* enable locale */
gtk_set_locale ();
gtk_init (&argc, &argv);
ttip = create_yellow_tooltips();
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name(window, "TiMidity");
gtk_window_set_title(GTK_WINDOW(window), "TiMidity - MIDI Player");
gtk_window_set_wmclass(GTK_WINDOW(window), "timidity", "TiMidity");
gtk_signal_connect(GTK_OBJECT(window), "delete_event",
GTK_SIGNAL_FUNC (delete_event), NULL);
gtk_signal_connect(GTK_OBJECT(window), "destroy",
GTK_SIGNAL_FUNC (destroy), NULL);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
mbar = create_menubar();
gtk_box_pack_start(GTK_BOX(vbox), mbar, FALSE, FALSE, 0);
scrolled_win = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(vbox), scrolled_win, TRUE, TRUE ,0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_widget_show(scrolled_win);
#ifdef HAVE_GTK_2
text = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD);
#else
text = gtk_text_new(NULL, NULL);
#endif
gtk_widget_show(text);
gtk_container_add(GTK_CONTAINER(scrolled_win), text);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 4);
gtk_widget_show(hbox);
adj = gtk_adjustment_new(0., 0., 100., 1., 20., 0.);
locator = gtk_hscale_new(GTK_ADJUSTMENT(adj));
gtk_scale_set_draw_value(GTK_SCALE(locator), TRUE);
gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
GTK_SIGNAL_FUNC(generic_scale_cb),
(gpointer)GTK_CHANGE_LOCATOR);
gtk_signal_connect(GTK_OBJECT(locator), "button_press_event",
GTK_SIGNAL_FUNC(locate_update_cb),
NULL);
gtk_signal_connect(GTK_OBJECT(locator), "button_release_event",
GTK_SIGNAL_FUNC(locate_update_cb),
NULL);
gtk_range_set_update_policy(GTK_RANGE(locator),
GTK_UPDATE_DISCONTINUOUS);
gtk_scale_set_digits(GTK_SCALE(locator), 0);
gtk_widget_show(locator);
gtk_box_pack_start(GTK_BOX(hbox), locator, TRUE, TRUE, 4);
align = gtk_alignment_new(0., 1., 1., 0.);
gtk_widget_show(align);
cnt_lbl = gtk_label_new("00:00");
gtk_widget_show(cnt_lbl);
gtk_container_add(GTK_CONTAINER(align), cnt_lbl);
gtk_box_pack_start(GTK_BOX(hbox), align, FALSE, TRUE, 0);
align = gtk_alignment_new(0., 1., 1., 0.);
gtk_widget_show(align);
tot_lbl = gtk_label_new("/00:00");
gtk_widget_show(tot_lbl);
gtk_container_add(GTK_CONTAINER(align), tot_lbl);
gtk_box_pack_start(GTK_BOX(hbox), align, FALSE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 4);
swin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
clist = gtk_clist_new(1);
gtk_container_add(GTK_CONTAINER(swin), clist);
gtk_widget_show(swin);
gtk_widget_show(clist);
gtk_widget_set_usize(clist, 200, 10);
gtk_clist_set_reorderable(GTK_CLIST(clist), TRUE);
gtk_clist_set_button_actions(GTK_CLIST(clist), 0, GTK_BUTTON_SELECTS);
gtk_clist_set_button_actions(GTK_CLIST(clist), 1, GTK_BUTTON_DRAGS);
gtk_clist_set_button_actions(GTK_CLIST(clist), 2, GTK_BUTTON_SELECTS);
gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_SINGLE);
gtk_clist_set_column_auto_resize(GTK_CLIST(clist), 1, TRUE);
gtk_signal_connect(GTK_OBJECT(clist), "select_row",
GTK_SIGNAL_FUNC(file_list_cb), NULL);
gtk_box_pack_start(GTK_BOX(hbox), swin, TRUE, TRUE, 0);
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox2, FALSE, FALSE, 0);
gtk_widget_show(vbox2);
/* This is so the pixmap creation works properly. */
gtk_widget_realize(window);
set_icon_pixmap(window, timidity_xpm);
gtk_box_pack_start(GTK_BOX(vbox2),
create_pixmap_label(window, loud_xpm),
FALSE, FALSE, 0);
adj = gtk_adjustment_new(30., 0., (gfloat)MAX_AMPLIFICATION, 1., 20., 0.);
vol_scale = gtk_vscale_new(GTK_ADJUSTMENT(adj));
gtk_scale_set_draw_value(GTK_SCALE(vol_scale), FALSE);
gtk_signal_connect (GTK_OBJECT(adj), "value_changed",
GTK_SIGNAL_FUNC(generic_scale_cb),
(gpointer)GTK_CHANGE_VOLUME);
gtk_range_set_update_policy(GTK_RANGE(vol_scale),
GTK_UPDATE_DELAYED);
gtk_widget_show(vol_scale);
gtk_tooltips_set_tip(ttip, vol_scale, "Volume control", NULL);
gtk_box_pack_start(GTK_BOX(vbox2), vol_scale, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox2),
create_pixmap_label(window, quiet_xpm),
FALSE, FALSE, 0);
handlebox = gtk_handle_box_new();
gtk_box_pack_start(GTK_BOX(hbox), handlebox, FALSE, FALSE, 0);
table = gtk_table_new(7, 2, TRUE);
gtk_container_add(GTK_CONTAINER(handlebox), table);
button = create_button_with_pixmap(window, playpaus_xpm, GTK_PAUSE,
"Play/Pause");
gtk_table_attach_defaults(GTK_TABLE(table), button,
0, 2, 0, 1);
button = create_button_with_pixmap(window, prevtrk_xpm, GTK_PREV,
"Previous file");
gtk_table_attach_defaults(GTK_TABLE(table), button,
0, 1, 1, 2);
button = create_button_with_pixmap(window, nexttrk_xpm, GTK_NEXT,
"Next file");
gtk_table_attach_defaults(GTK_TABLE(table), button,
1, 2, 1, 2);
button = create_button_with_pixmap(window, rew_xpm, GTK_RWD,
"Rewind");
gtk_table_attach_defaults(GTK_TABLE(table), button,
0, 1, 2, 3);
button = create_button_with_pixmap(window, ff_xpm, GTK_FWD,
"Fast forward");
gtk_table_attach_defaults(GTK_TABLE(table), button,
1, 2, 2, 3);
button = create_button_with_pixmap(window, keydown_xpm, GTK_KEYDOWN,
"Lower pitch");
gtk_table_attach_defaults(GTK_TABLE(table), button,
0, 1, 3, 4);
button = create_button_with_pixmap(window, keyup_xpm, GTK_KEYUP,
"Raise pitch");
gtk_table_attach_defaults(GTK_TABLE(table), button,
1, 2, 3, 4);
button = create_button_with_pixmap(window, slow_xpm, GTK_SLOWER,
"Decrease tempo");
gtk_table_attach_defaults(GTK_TABLE(table), button,
0, 1, 4, 5);
button = create_button_with_pixmap(window, fast_xpm, GTK_FASTER,
"Increase tempo");
gtk_table_attach_defaults(GTK_TABLE(table), button,
1, 2, 4, 5);
button = create_button_with_pixmap(window, restart_xpm, GTK_RESTART,
"Restart");
gtk_table_attach_defaults(GTK_TABLE(table), button,
0, 1, 5, 6);
button = create_button_with_pixmap(window, open_xpm, 0,
"Open");
#ifdef HAVE_GTK_2
gtk_signal_disconnect_by_func(GTK_OBJECT(button), G_CALLBACK(generic_cb), 0);
#else
gtk_signal_disconnect_by_func(GTK_OBJECT(button), generic_cb, 0);
#endif
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(open_file_cb), 0);
gtk_table_attach_defaults(GTK_TABLE(table), button,
1, 2, 5, 6);
button = create_button_with_pixmap(window, quit_xpm, GTK_QUIT,
"Quit");
gtk_table_attach_defaults(GTK_TABLE(table), button,
0, 2, 6, 7);
gtk_widget_show(hbox);
gtk_widget_show(vbox);
gtk_widget_show(table);
gtk_widget_show(handlebox);
gtk_widget_show(window);
gdk_input_add(pipe_number, GDK_INPUT_READ, handle_input, NULL);
gtk_main();
}
GtkWidget *
scale_create_widget (GtkWidget * dlg)
{
GtkWidget *w;
GtkAdjustment *adj;
gint page;
if (options.scale_data.min_value >= options.scale_data.max_value)
{
g_printerr (_("Maximum value must be greater than minimum value.\n"));
return NULL;
}
/* check for initial value */
if (options.scale_data.have_value)
{
if (options.scale_data.value < options.scale_data.min_value)
{
g_printerr (_("Initial value less than minimal.\n"));
options.scale_data.value = options.scale_data.min_value;
}
else if (options.scale_data.value > options.scale_data.max_value)
{
g_printerr (_("Initial value greater than maximum.\n"));
options.scale_data.value = options.scale_data.max_value;
}
}
else
options.scale_data.value = options.scale_data.min_value;
page = options.scale_data.page == -1 ? options.scale_data.step * 10 : options.scale_data.page;
/* this type conversion needs only for gtk-2.0 */
adj = (GtkAdjustment *) gtk_adjustment_new ((double) options.scale_data.value,
(double) options.scale_data.min_value,
(double) options.scale_data.max_value,
(double) options.scale_data.step,
(double) page,
0.0);
if (options.common_data.vertical)
{
#if GTK_CHECK_VERSION(3,0,0)
scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adj));
#else
scale = gtk_vscale_new (GTK_ADJUSTMENT (adj));
#endif
gtk_range_set_inverted (GTK_RANGE (scale), !options.scale_data.invert);
}
else
{
#if GTK_CHECK_VERSION(3,0,0)
scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adj));
#else
scale = gtk_hscale_new (GTK_ADJUSTMENT (adj));
#endif
gtk_range_set_inverted (GTK_RANGE (scale), options.scale_data.invert);
}
gtk_widget_set_name (scale, "yad-scale-widget");
gtk_scale_set_digits (GTK_SCALE (scale), 0);
if (options.scale_data.hide_value)
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
/* add marks */
if (options.scale_data.marks)
{
GtkPositionType pos;
GSList *m = options.scale_data.marks;
pos = options.common_data.vertical ? GTK_POS_LEFT : GTK_POS_BOTTOM;
for (; m; m = m->next)
{
YadScaleMark *mark = (YadScaleMark *) m->data;
gtk_scale_add_mark (GTK_SCALE (scale), mark->value, pos, mark->name);
}
}
/* create container */
if (options.common_data.vertical)
{
#if GTK_CHECK_VERSION(3,0,0)
w = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
#else
w = gtk_vbox_new (FALSE, 1);
#endif
}
else
{
#if GTK_CHECK_VERSION(3,0,0)
w = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1);
#else
w = gtk_hbox_new (FALSE, 1);
#endif
}
/* create buttons */
if (options.scale_data.buttons)
{
minus_btn = gtk_button_new_with_label ("-");
gtk_button_set_relief (GTK_BUTTON (minus_btn), GTK_RELIEF_NONE);
g_signal_connect (G_OBJECT (minus_btn), "clicked", G_CALLBACK (vb_pressed), GINT_TO_POINTER (MINUS_BTN));
gtk_widget_set_sensitive (minus_btn, (options.scale_data.value > options.scale_data.min_value));
plus_btn = gtk_button_new_with_label ("+");
gtk_button_set_relief (GTK_BUTTON (plus_btn), GTK_RELIEF_NONE);
g_signal_connect (G_OBJECT (plus_btn), "clicked", G_CALLBACK (vb_pressed), GINT_TO_POINTER (PLUS_BTN));
gtk_widget_set_sensitive (plus_btn, (options.scale_data.value < options.scale_data.max_value));
}
/* create complex widget */
if (options.scale_data.buttons)
gtk_box_pack_start (GTK_BOX (w), options.common_data.vertical ? plus_btn : minus_btn, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (w), scale, TRUE, TRUE, 2);
if (options.scale_data.buttons)
gtk_box_pack_start (GTK_BOX (w), options.common_data.vertical ? minus_btn : plus_btn, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (scale), "value-changed", G_CALLBACK (value_changed_cb), NULL);
gtk_widget_grab_focus (scale);
return w;
}
GtkWidget * yank_app_new(EYank *yank)
{
yank_preferences *prefs;
static GtkTargetEntry drop_types[] =
{
{ "text/uri-list", 0, 1 },
};
static gint n_drop_types = sizeof (drop_types)/sizeof (drop_types [0]);
gchar *treetitle[] =
{
_("NoteTree"),
NULL
};
gchar *todotitles[] =
{
_("Deadline"),
_("Priority"),
_("Complete"),
_("Title"),
NULL
};
GtkWidget *app;
GtkWidget *scrolledwindow1;
GtkWidget *scrolledwindow2;
GtkWidget *scrolledwindow3;
GtkWidget *hbox;
GtkWidget *hbox3;
GtkWidget *vbox;
GtkWidget *label;
GdkFont *font;
GtkObject *prio_adjust;
/* gint got_crash; */
GtkWidget *b_toggle_ext_flags;
GtkWidget *hbox_ext_flags;
GtkWidget *hpaned;
hpaned = app = yank->priv->hpaned;
yank_main_app(app);
sp->edit_tree = NULL;
sp->title_entry =NULL;
sp->todo_check =NULL;
sp->prio_entry =NULL;
sp->de_deadline =NULL;
sp->ad_complete =NULL;
sp->tlabel_created =NULL;
sp->tlabel_changed =NULL;
sp->label_changes =NULL;
sp->tlabel_expire =NULL;
sp->note_id_entry =NULL;
sp->text_entry =NULL;
sp->note_tree =NULL;
sp->b_ok =NULL;
sp->b_apply =NULL;
sp->b_cancel =NULL;
sp->todolist =NULL;
sp->notebook =NULL;
sp->status =NULL;
sp->prio_date_box =NULL;
sp->edit_tree=NULL;
yank_root_win(GTK_WINDOW(app));
/*
* main tree
*/
scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
/* gtk_widget_show will be called later */
/* gtk_container_add(GTK_CONTAINER(hpaned), scrolledwindow1); */
e_paned_add1(E_PANED(hpaned), scrolledwindow1);
sp->note_tree = gtk_ctree_new_with_titles(1, 0, treetitle);
gtk_widget_show(sp->note_tree);
gtk_container_add(GTK_CONTAINER(scrolledwindow1), sp->note_tree);
gtk_clist_set_column_width(GTK_CLIST(sp->note_tree), 0, 80);
gtk_clist_set_column_auto_resize(GTK_CLIST(sp->note_tree), 0, TRUE);
gtk_clist_set_row_height(GTK_CLIST(sp->note_tree), 19);
gtk_clist_set_selection_mode(GTK_CLIST(sp->note_tree), GTK_SELECTION_EXTENDED);
gtk_clist_set_reorderable(GTK_CLIST(sp->note_tree), TRUE);
gtk_clist_set_use_drag_icons(GTK_CLIST(sp->note_tree), TRUE);
gtk_clist_column_titles_show(GTK_CLIST(sp->note_tree));
gtk_signal_connect(GTK_OBJECT(sp->note_tree), "tree_select_row",
GTK_SIGNAL_FUNC (note_tree_row_selected), NULL);
gtk_signal_connect(GTK_OBJECT(sp->note_tree), "tree_unselect_row",
GTK_SIGNAL_FUNC (note_tree_row_unselected), NULL);
gtk_signal_connect(GTK_OBJECT(sp->note_tree), "click_column",
GTK_SIGNAL_FUNC (cb_note_tree_col_selected), NULL);
gtk_signal_connect(GTK_OBJECT(sp->note_tree), "drag_data_received",
GTK_SIGNAL_FUNC(cb_note_tree_reordered), NULL);
/*
* FIXME:
* dnd on the note-tree disables reordering of notes by dnd
*/
/* gtk_signal_connect(GTK_OBJECT(sp->note_tree), "drag_data_received", */
/* GTK_SIGNAL_FUNC(cb_note_tree_drop), NULL); */
/* gtk_drag_dest_set(sp->note_tree, GTK_DEST_DEFAULT_MOTION | */
/* GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, */
/* drop_types, n_drop_types, GDK_ACTION_COPY); */
sp->notebook = gtk_notebook_new();
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(sp->notebook), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(sp->notebook), FALSE);
gtk_widget_show(sp->notebook);
/* gtk_container_add(GTK_CONTAINER(hpaned), sp->notebook); */
e_paned_add2(E_PANED(hpaned), sp->notebook);
/*
* todo-list
*/
scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show(scrolledwindow2);
gtk_container_add(GTK_CONTAINER(sp->notebook), scrolledwindow2);
sp->todolist = gtk_clist_new_with_titles(4, todotitles);
gtk_signal_connect(GTK_OBJECT(sp->todolist), "select_row",
GTK_SIGNAL_FUNC (cb_todo_row_selected), NULL);
gtk_signal_connect(GTK_OBJECT(sp->todolist), "click_column",
GTK_SIGNAL_FUNC (cb_todo_col_selected), NULL);
gtk_signal_connect(GTK_OBJECT(sp->todolist), "drag_data_received",
GTK_SIGNAL_FUNC(cb_todo_list_drop), NULL);
gtk_drag_dest_set(sp->todolist, GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
drop_types, n_drop_types, GDK_ACTION_COPY);
gtk_widget_show(sp->todolist);
gtk_container_add(GTK_CONTAINER(scrolledwindow2), sp->todolist);
gtk_clist_column_titles_show(GTK_CLIST(sp->todolist));
gtk_clist_set_column_auto_resize(GTK_CLIST(sp->todolist), 0 , TRUE);
gtk_clist_set_column_auto_resize(GTK_CLIST(sp->todolist), 3 , TRUE);
gtk_clist_set_column_justification(GTK_CLIST(sp->todolist), 1,
GTK_JUSTIFY_RIGHT);
gtk_clist_set_column_justification(GTK_CLIST(sp->todolist), 2,
GTK_JUSTIFY_RIGHT);
/*
* text/ data
*/
vbox = gtk_vbox_new(FALSE, 3);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER (sp->notebook), vbox);
hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
sp->prio_date_box = gtk_vbox_new(FALSE, 3);
gtk_widget_show(sp->prio_date_box);
gtk_box_pack_start(GTK_BOX(vbox), sp->prio_date_box, FALSE, FALSE, 0);
hbox_ext_flags = gui_ext_flags();
gtk_box_pack_start(GTK_BOX(vbox), hbox_ext_flags, FALSE, FALSE, 3);
label = gtk_label_new(_("Title:"));
font = gtk_widget_get_style(label)->font;
gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
sp->title_entry = gtk_entry_new();
gtk_widget_set_usize(sp->title_entry, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(sp->title_entry);
gtk_box_pack_start(GTK_BOX(hbox), sp->title_entry, TRUE, TRUE, 5);
sp->todo_check = gtk_check_button_new_with_label(_("Done"));
gtk_widget_set_usize(sp->todo_check, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(sp->todo_check);
gtk_box_pack_start(GTK_BOX(hbox), sp->todo_check, FALSE, FALSE, 5);
/*
* button for extra flags& data
*/
b_toggle_ext_flags = gtk_button_new();
{
GtkWidget *p_up;
GtkWidget *p_down;
GtkWidget *box;
box = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(b_toggle_ext_flags), box);
gtk_widget_show(box);
p_up = gnome_stock_pixmap_widget_at_size(
GTK_WIDGET(yank_root_win(NULL)), GNOME_STOCK_BUTTON_UP, 12, 14);
p_down = gnome_stock_pixmap_widget_at_size(
GTK_WIDGET(yank_root_win(NULL)), GNOME_STOCK_BUTTON_DOWN, 12, 14);
gtk_widget_hide(p_up);
gtk_widget_show(p_down);
gtk_container_add(GTK_CONTAINER(box), p_up);
gtk_container_add(GTK_CONTAINER(box), p_down);
gtk_object_set_data(GTK_OBJECT(b_toggle_ext_flags), "up", p_up);
gtk_object_set_data(GTK_OBJECT(b_toggle_ext_flags), "down", p_down);
}
gtk_widget_show(b_toggle_ext_flags);
gtk_box_pack_start(GTK_BOX(hbox), b_toggle_ext_flags, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(b_toggle_ext_flags), "clicked",
GTK_SIGNAL_FUNC(cb_toggle_ext_flags), hbox_ext_flags);
/*
* deadline/ prio/ complete
*/
{
GtkWidget *prio_hbox1;
GtkWidget *prio_hbox2;
GtkWidget *sc_complete;
prio_hbox1 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(prio_hbox1);
gtk_box_pack_start(GTK_BOX(sp->prio_date_box), prio_hbox1, FALSE, FALSE,
0);
prio_hbox2 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(prio_hbox2);
gtk_box_pack_start(GTK_BOX(sp->prio_date_box), prio_hbox2, FALSE, FALSE,
0);
label = gtk_label_new(_("Deadline:"));
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(prio_hbox1), label, FALSE, FALSE, 5);
sp->de_deadline = gnome_date_edit_new(0, 1, 1);
gnome_date_edit_set_popup_range(GNOME_DATE_EDIT(sp->de_deadline), 0, 23);
gtk_widget_set_sensitive(GNOME_DATE_EDIT(sp->de_deadline)->date_entry,
FALSE);
gtk_widget_set_sensitive(GNOME_DATE_EDIT(sp->de_deadline)->time_entry,
FALSE);
gtk_widget_show(sp->de_deadline);
gtk_box_pack_start(GTK_BOX(prio_hbox1), sp->de_deadline, FALSE, FALSE, 0);
label = gtk_label_new(_("Priority:"));
gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(prio_hbox1), label, FALSE, FALSE, 5);
prio_adjust = gtk_adjustment_new(0, 0, 9999, 1, 10, 10);
sp->prio_entry = gtk_spin_button_new(GTK_ADJUSTMENT(prio_adjust), 1, 0);
/* NOTE: this is note 100% ok */
gtk_widget_set_usize(GTK_WIDGET(sp->prio_entry),
gdk_string_width(font, "999999") + 10,
gdk_string_height(font, "W") + 10);
gtk_widget_show(sp->prio_entry);
gtk_box_pack_start(GTK_BOX(prio_hbox1), sp->prio_entry, FALSE, FALSE, 0);
label = gtk_label_new(_("Complete:"));
gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(prio_hbox2), label, FALSE, FALSE, 5);
sp->ad_complete = gtk_adjustment_new(0, 0, 101, 1, 1, 1);
sc_complete = gtk_hscale_new(GTK_ADJUSTMENT(sp->ad_complete));
gtk_scale_set_digits(GTK_SCALE(sc_complete), 0);
gtk_scale_set_value_pos(GTK_SCALE(sc_complete), GTK_POS_LEFT);
gtk_widget_show(sc_complete);
gtk_box_pack_start(GTK_BOX(prio_hbox2), sc_complete, TRUE, TRUE, 5);
label = gtk_label_new(_("%"));
gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(prio_hbox2), label, FALSE, FALSE, 5);
}
/*
* additional note data
*/
sp->note_id_entry = gtk_entry_new();
/* gtk_widget_show(sp->note_id_entry); */
gtk_widget_hide(sp->note_id_entry);
gtk_box_pack_start(GTK_BOX(hbox), sp->note_id_entry, FALSE, FALSE, 5);
/*
* note text
*/
scrolledwindow3 = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow3),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show(scrolledwindow3);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow3, TRUE, TRUE, 0);
sp->text_entry = gtk_text_new(NULL, NULL);
gtk_text_set_editable(GTK_TEXT(sp->text_entry), TRUE);
gtk_widget_show(sp->text_entry);
gtk_container_add(GTK_CONTAINER(scrolledwindow3), sp->text_entry);
/* text dnd */
gtk_signal_connect(GTK_OBJECT(sp->text_entry), "drag_data_received",
GTK_SIGNAL_FUNC(cb_text_entry_drop), NULL);
gtk_drag_dest_set(sp->text_entry, GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
drop_types, n_drop_types, GDK_ACTION_COPY);
hbox3 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox3);
gtk_box_pack_start(GTK_BOX(vbox), hbox3, FALSE, FALSE, 3);
sp->b_ok = gnome_stock_button(GNOME_STOCK_BUTTON_OK);
gtk_widget_show(sp->b_ok);
gtk_box_pack_start(GTK_BOX(hbox3), sp->b_ok, TRUE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(sp->b_ok), "clicked",
GTK_SIGNAL_FUNC(cb_b_ok), NULL);
sp->b_apply = gnome_stock_button(GNOME_STOCK_BUTTON_APPLY);
gtk_widget_show(sp->b_apply);
gtk_box_pack_start(GTK_BOX(hbox3), sp->b_apply, TRUE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(sp->b_apply), "clicked",
GTK_SIGNAL_FUNC(cb_b_apply), NULL);
sp->b_cancel = gnome_stock_button(GNOME_STOCK_BUTTON_CANCEL);
gtk_widget_show(sp->b_cancel);
gtk_box_pack_start(GTK_BOX(hbox3), sp->b_cancel, TRUE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(sp->b_cancel), "clicked",
GTK_SIGNAL_FUNC(cb_b_cancel), NULL);
/*
* a bit suboptimal
*/
gtk_signal_connect(GTK_OBJECT(sp->title_entry), "changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->de_deadline), "date-changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->de_deadline), "time-changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->tlabel_expire), "time_changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->prio_entry), "changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->ad_complete), "value_changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->ad_complete), "value_changed",
GTK_SIGNAL_FUNC(cb_complete_updates_done), sp->todo_check);
gtk_signal_connect(GTK_OBJECT(sp->todo_check), "toggled",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->text_entry), "changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
/*
* keyboard-control
*/
gtk_signal_connect(GTK_OBJECT(sp->title_entry), "activate",
GTK_SIGNAL_FUNC(cb_finished_note), NULL);
gtk_signal_connect(GTK_OBJECT(sp->text_entry), "activate",
GTK_SIGNAL_FUNC(cb_finished_note), NULL);
/*
* create pixmaps
*/
pix_text_xpm = gnome_pixmap_new_from_xpm_d(text_xpm);
gtk_widget_show(pix_text_xpm);
pix_box_xpm = gnome_pixmap_new_from_xpm_d(box_xpm);
gtk_widget_show(pix_box_xpm);
pix_box2_xpm = gnome_pixmap_new_from_xpm_d(box2_xpm);
gtk_widget_show(pix_box2_xpm);
pix_circle_xpm = gnome_pixmap_new_from_xpm_d(circle_xpm);
gtk_widget_show(pix_circle_xpm);
pix_circle2_xpm = gnome_pixmap_new_from_xpm_d(circle2_xpm);
gtk_widget_show(pix_circle2_xpm);
/*
* menus
*/
/* gnome_app_set_contents(GNOME_APP(app), hpaned); */
/* sp->status = gnome_appbar_new(FALSE, TRUE, GNOME_PREFERENCES_USER); */
/* gnome_app_set_statusbar(GNOME_APP(app), sp->status); */
/* yank_install_menus_and_toolbar(app); */
yank_tree_item_context_menu(sp->note_tree);
yank_todo_item_context_menu(sp->todolist);
yank_text_item_context_menu(sp->title_entry);
yank_text_item_context_menu(sp->text_entry);
/* gtk_signal_connect(GTK_OBJECT(app), "delete_event", */
/* GTK_SIGNAL_FUNC(cb_delete_event), NULL); */
/*
* initialize preferences
* also preloads plugins
*/
load_preferences();
prefs = get_preferences();
gtk_text_set_word_wrap(GTK_TEXT(sp->text_entry), prefs->wordwrap);
gtk_text_set_line_wrap(GTK_TEXT(sp->text_entry), prefs->linewrap);
/* if (prefs->yank_width * prefs->yank_height) */
/* { */
/* gtk_window_set_default_size(GTK_WINDOW(app), prefs->yank_width, */
/* prefs->yank_height); */
/* } */
/* else */
/* { */
/* gtk_window_set_default_size(GTK_WINDOW(app), 600, 400); */
/* } */
if (prefs->use_custom_font)
{
if (prefs->note_font)
{
set_note_font_str(prefs->note_font);
}
if (prefs->note_tree_font)
{
set_note_tree_font_str(prefs->note_tree_font);
}
if (prefs->todolist_font)
{
set_todolist_font_str(prefs->todolist_font);
}
}
else
{
set_default_font();
}
/*
* parse geometry if given
*/
/* if (geometry != NULL) */
/* { */
/* gint x, y, w, h; */
/* if (gnome_parse_geometry(geometry, &x, &y, &w, &h )) */
/* { */
/* if (x != -1) */
/* { */
/* gtk_widget_set_uposition(app, x, y); */
/* } */
/* */
/* if (w != -1) */
/* { */
/* gtk_window_set_default_size(GTK_WINDOW(app), w, h); */
/* } */
/* } */
/* else */
/* { */
/* g_error(_("Could not parse geometry string `%s'"), geometry); */
/* } */
/* } */
/* */
/* if (prefs->note_tree_width) */
/* { */
/* gtk_widget_set_usize(scrolledwindow1, prefs->note_tree_width, -1); */
/* } */
/* else */
/* { */
/* gtk_widget_set_usize(scrolledwindow1, 200, -1); */
/* } */
/* gtk_widget_show(scrolledwindow1); */
/*
* try to read files from killed sessions
*/
/* got_crash = get_crash_file(); */
/*
* load file from the command-line
*/
/* if (file != NULL && ! got_crash) */
/* { */
/* load_notes_from_cli((gchar *)file, GTK_CTREE(sp->note_tree), NULL); */
/* } */
/*
* read default file
*/
/* if (file == NULL && ! got_crash) */
/* { */
/* get_def_file(); */
/* } */
/*
* register some signal-handlers
*/
/* if (signal(SIGTERM, handle_sigterm) == SIG_ERR) */
/* { */
/* g_warning("Can't handle SIGTERM"); */
/* } */
/* if (signal(SIGCHLD, handle_sigchild) == SIG_ERR) */
/* { */
/* g_warning("Can't handle SIGCHILD"); */
/* } */
/* if (signal(SIGPIPE, handle_sigpipe) == SIG_ERR) */
/* { */
/* g_warning("Can't handle SIGPIPE"); */
/* } */
/*
* init autosave
*/
/* if (prefs->auto_save_minutes) */
/* { */
/* autosave_notes(NULL); */
/* } */
return (hpaned);
}
