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); }