Options::Options(clan::Canvas &canvas) : clan::TextureWindow(canvas)
{
// Note, when changing these, remember to change the popup menu defaults
num_particles = 64;
point_size = 64;
int slider_xpos = 450;
int slider_label_xpos = slider_xpos + 200;
int slider_ypos = 100;
int slider_gap = 24;
slider_num_particles = create_slider(slider_xpos, slider_ypos);
slider_num_particles->set_max_position(1000);
slider_num_particles->set_position(num_particles);
slider_num_particles->func_value_changed() = bind_member(this, &Options::slider_num_particles_changed);
label_num_particles = create_slider_label(slider_label_xpos, slider_ypos);
slider_ypos += slider_gap;
slider_point_size = create_slider(slider_xpos, slider_ypos);
slider_point_size->set_min_position(1);
slider_point_size->set_max_position(256);
slider_point_size->set_position(point_size);
slider_point_size->func_value_changed() = bind_member(this, &Options::slider_point_size_changed);
label_point_size = create_slider_label(slider_label_xpos, slider_ypos);
slider_ypos += slider_gap;
update_all_slider_text();
}
Options::Options(CL_GUIManager &gui, CL_Rect gui_position) : CL_GUIComponent(&gui, CL_GUITopLevelDescription("Options", gui_position, false))
{
// Note, when changing these, remember to change the popup menu defaults
num_particles = 64;
point_size = 64;
int slider_xpos = 450;
int slider_ypos = 100;
int slider_gap = 24;
slider_num_particles = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
slider_num_particles->set_max(1000);
slider_num_particles->set_position(num_particles);
slider_num_particles->func_value_changed().set(this, &Options::slider_num_particles_changed);
slider_ypos += 8;
label_num_particles = create_slider_label(slider_num_particles);
slider_point_size = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
slider_point_size->set_max(256);
slider_point_size->set_position(point_size);
slider_point_size->func_value_changed().set(this, &Options::slider_point_size_changed);
slider_ypos += 8;
label_point_size = create_slider_label(slider_point_size);
update_all_slider_text();
func_render().set(this, &Options::on_render);
}
static GtkWidget * create_window (void)
{
const char * const names[AUD_EQUALIZER_NBANDS] = {N_("31 Hz"), N_("63 Hz"),
N_("125 Hz"), N_("250 Hz"), N_("500 Hz"), N_("1 kHz"), N_("2 kHz"),
N_("4 kHz"), N_("8 kHz"), N_("16 kHz")};
GtkWidget * window, * vbox, * hbox;
int i;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title ((GtkWindow *) window, _("Equalizer"));
gtk_window_set_type_hint ((GtkWindow *) window, GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_resizable ((GtkWindow *) window, FALSE);
gtk_container_set_border_width ((GtkContainer *) window, 6);
g_signal_connect ((GObject *) window, "delete-event", (GCallback)
gtk_widget_hide_on_delete, NULL);
audgui_hide_on_escape (window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add ((GtkContainer *) window, vbox);
gtk_box_pack_start ((GtkBox *) vbox, create_on_off (), FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox, hbox, FALSE, FALSE, 0);
gtk_box_pack_start ((GtkBox *) hbox, create_slider (_("Preamp"), -1), FALSE, FALSE, 0);
gtk_box_pack_start ((GtkBox *) hbox,
gtk_separator_new (GTK_ORIENTATION_VERTICAL), FALSE, FALSE, 0);
for (i = 0; i < AUD_EQUALIZER_NBANDS; i ++)
gtk_box_pack_start ((GtkBox *) hbox, create_slider (_(names[i]), i), FALSE, FALSE, 0);
gtk_widget_show_all (vbox);
return window;
}
Options::Options(clan::GUIManager &gui, clan::Rect gui_position) : clan::GUIComponent(&gui, clan::GUITopLevelDescription("Options", gui_position, false))
{
// Note, when changing these, remember to change the popup menu defaults
compare_function = clan::compare_greater;
stencil_pass = clan::stencil_keep;
stencil_fail = clan::stencil_incr;
num_balls = 9;
is_moveballs_set = true;
is_circle_set = true;
compare_reference = 1;
int slider_xpos = 400;
int slider_ypos = 250;
int slider_gap = 24;
slider_numballs = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
slider_numballs->set_max(9);
slider_numballs->set_position(num_balls);
slider_numballs->func_value_changed() = bind_member(this, &Options::slider_numballs_changed);
slider_ypos += 8;
label_numballs = create_slider_label(slider_numballs);
slider_ypos += 8;
slider_compare_reference = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
slider_compare_reference->set_max(16);
slider_compare_reference->set_position(compare_reference);
slider_compare_reference->func_value_changed() = bind_member(this, &Options::slider_compare_reference_changed);
slider_ypos += 8;
label_compare_reference = create_slider_label(slider_compare_reference);
int checkbox_xpos = slider_xpos;
int checkbox_ypos = slider_ypos;
int checkbox_gap = 24;
checkbox_moveballs = create_checkbox(checkbox_xpos, checkbox_ypos, "Moving Balls", is_moveballs_set);
checkbox_moveballs->func_state_changed() = bind_member(this, &Options::checkbox_moveballs_changed);
checkbox_ypos += checkbox_gap + 8;
checkbox_circle = create_checkbox(checkbox_xpos, checkbox_ypos, "Draw Stencil Circle (Without selected stencil options)", is_circle_set);
checkbox_circle->func_state_changed() = bind_member(this, &Options::checkbox_circle_changed);
checkbox_ypos += checkbox_gap + 8;
make_compare_menu(combo_compare_menu);
combo_comparefunc = create_compare_combo_box(600, 40, combo_compare_menu, 3);
label_comparefunc = create_combobox_label(combo_comparefunc, "Compare Function");
make_passfail_menu(combo_pass_menu);
combo_pass = create_passfail_combo_box(600, 80, combo_pass_menu, 0);
label_pass = create_combobox_label(combo_pass, "Pass Operation");
make_passfail_menu(combo_fail_menu);
combo_fail = create_passfail_combo_box(600, 120, combo_fail_menu, 3);
label_fail = create_combobox_label(combo_fail, "Fail Operation");
update_all_slider_text();
func_render() = bind_member(this, &Options::on_render);
}
void OptionRGB::setup(clan::GUIComponent *base_component, const std::string &name, int xpos, int ypos)
{
checkbox = new clan::CheckBox(base_component);
int width = 100;
int height = 16;
checkbox->set_geometry(clan::Rect(xpos, ypos , clan::Size(width, height)));
xpos += width;
checkbox->set_text(name);
checkbox->set_checked(false);
checkbox->func_state_changed() = bind_member(this, &OptionRGB::checkbox_changed);
int slider_width = 64;
slider_red = create_slider(base_component, clan::Rect(xpos, ypos, clan::Size(slider_width, 17)));
xpos += slider_width + 4;
slider_red->func_value_changed() = bind_member(this, &OptionRGB::slider_red_changed);
int spin_width = 40;
spin_red = new clan::Spin(base_component);
spin_red->set_geometry(clan::Rect(xpos, ypos - 3, clan::Size(spin_width, 21)));
xpos += spin_width + 4;
spin_red->set_ranges(0, 255);
spin_red->func_value_changed() = bind_member(this, &OptionRGB::spin_red_changed);
slider_green = create_slider(base_component, clan::Rect(xpos, ypos, clan::Size(slider_width, 17)));
xpos += slider_width + 4;
slider_green->func_value_changed() = bind_member(this, &OptionRGB::slider_green_changed);
spin_green = new clan::Spin(base_component);
spin_green->set_geometry(clan::Rect(xpos, ypos - 3, clan::Size(spin_width, 21)));
xpos += spin_width + 4;
spin_green->set_ranges(0, 255);
spin_green->func_value_changed() = bind_member(this, &OptionRGB::spin_green_changed);
slider_blue = create_slider(base_component, clan::Rect(xpos, ypos, clan::Size(slider_width, 17)));
xpos += slider_width + 4;
slider_blue->func_value_changed() = bind_member(this, &OptionRGB::slider_blue_changed);
spin_blue = new clan::Spin(base_component);
spin_blue->set_geometry(clan::Rect(xpos, ypos - 3, clan::Size(spin_width, 21)));
xpos += spin_width + 4;
spin_blue->set_ranges(0, 255);
spin_blue->func_value_changed() = bind_member(this, &OptionRGB::spin_blue_changed);
slider_red_changed();
slider_green_changed();
slider_blue_changed();
checkbox_changed();
}
Options::Options(clan::Canvas &canvas) : clan::TextureWindow(canvas)
{
// Note, when changing these, remember to change the popup menu defaults
current_mapmode = clan::map_2d_upper_left;
num_balls = 3;
grid_angle = 0;
is_moveballs_set = true;
int slider_xpos = 450;
int slider_label_xpos = slider_xpos + 200;
int slider_ypos = 100;
int slider_gap = 24;
slider_numballs = create_slider(slider_xpos, slider_ypos);
slider_numballs->set_max_position(9);
slider_numballs->set_position(num_balls);
slider_numballs->func_value_changed() = bind_member(this, &Options::slider_numballs_changed);
label_numballs = create_slider_label(slider_label_xpos, slider_ypos);
slider_ypos += slider_gap;
slider_grid_angle = create_slider(slider_xpos, slider_ypos);
slider_grid_angle->set_min_position(-45);
slider_grid_angle->set_max_position(90);
slider_grid_angle->set_position(grid_angle);
slider_grid_angle->func_value_changed() = bind_member(this, &Options::slider_grid_angle_changed);
label_grid_angle = create_slider_label(slider_label_xpos, slider_ypos);
slider_ypos += slider_gap;
int checkbox_xpos = slider_xpos;
int checkbox_ypos = slider_ypos;
int checkbox_gap = 24;
checkbox_moveballs = create_checkbox(checkbox_xpos, checkbox_ypos, "Moving Balls", is_moveballs_set);
checkbox_moveballs->func_state_changed() = bind_member(this, &Options::checkbox_moveballs_changed);
listbox_mapmode = Theme::create_listbox();
listbox_mapmode->style()->set("position: absolute; left:%1px; top:%2px; width:%3px; height:auto;", checkbox_xpos, 10, 180);
listbox_mapmode->set_items<std::string>( { "2d Upper Left", "2d Lower Left", "User Projection" }, Theme::create_listbox_label);
listbox_mapmode->func_selection_changed() = bind_member(this, &Options::on_mapmode_selected);
listbox_mapmode->set_selected_item(0);
add_subview(listbox_mapmode);
label_mapmode = Theme::create_label(true);
add_subview(label_mapmode);
label_mapmode->style()->set("position: absolute; left:%1px; top:%2px", slider_label_xpos, 10);
label_mapmode->set_text("Map Mode");
update_all_slider_text();
}
void set_slider_position(GuiObject * slid, int position)
{
check_object(slid, "slid", "set_slider_position");
slid->position = position;
create_slider(slid);
}
void set_slider_barlength(GuiObject * slid, int length)
{
check_object(slid, "slid", "set_slider_barlength");
slid->length = length;
create_slider(slid);
}
void set_slider_maxvalue(GuiObject * slid, float max)
{
check_object(slid, "slid", "set_slider_maxvalue");
if (max > 999)
max = 999;
slid->max_value = max;
create_slider(slid);
}
static GtkWidget * create_window (void)
{
const char * const names[AUD_EQUALIZER_NBANDS] = {N_("31 Hz"), N_("63 Hz"),
N_("125 Hz"), N_("250 Hz"), N_("500 Hz"), N_("1 kHz"), N_("2 kHz"),
N_("4 kHz"), N_("8 kHz"), N_("16 kHz")};
GtkWidget * window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title ((GtkWindow *) window, _("Equalizer"));
gtk_window_set_type_hint ((GtkWindow *) window, GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_resizable ((GtkWindow *) window, FALSE);
gtk_container_set_border_width ((GtkContainer *) window, 6);
audgui_destroy_on_escape (window);
GtkWidget * vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add ((GtkContainer *) window, vbox);
gtk_box_pack_start ((GtkBox *) vbox, create_on_off (), FALSE, FALSE, 0);
GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox, hbox, FALSE, FALSE, 0);
GtkWidget * preamp = create_slider (_("Preamp"), -1, hbox);
g_object_set_data ((GObject *) window, "preamp", preamp);
gtk_box_pack_start ((GtkBox *) hbox,
gtk_separator_new (GTK_ORIENTATION_VERTICAL), FALSE, FALSE, 0);
for (int i = 0; i < AUD_EQUALIZER_NBANDS; i ++)
{
GtkWidget * slider = create_slider (_(names[i]), i, hbox);
SPRINTF (slider_id, "slider%d", i);
g_object_set_data ((GObject *) window, slider_id, slider);
}
update_sliders (NULL, window);
hook_associate ("set equalizer_preamp", (HookFunction) update_sliders, window);
hook_associate ("set equalizer_bands", (HookFunction) update_sliders, window);
g_signal_connect (window, "destroy", (GCallback) destroy_cb, NULL);
return window;
}
Options::Options(clan::GUIManager &gui, clan::Rect gui_position) : clan::GUIComponent(&gui, clan::GUITopLevelDescription("Options", gui_position, false))
{
// Note, when changing these, remember to change the popup menu defaults
current_mapmode = clan::map_2d_upper_left;
num_balls = 3;
grid_angle = 0;
is_moveballs_set = true;
int slider_xpos = 450;
int slider_ypos = 100;
int slider_gap = 24;
slider_numballs = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
slider_numballs->set_max(9);
slider_numballs->set_position(num_balls);
slider_numballs->func_value_changed().set(this, &Options::slider_numballs_changed);
slider_ypos += 8;
label_numballs = create_slider_label(slider_numballs);
slider_grid_angle = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
slider_grid_angle->set_min(-45);
slider_grid_angle->set_max(90);
slider_grid_angle->set_position(grid_angle);
slider_grid_angle->func_value_changed().set(this, &Options::slider_grid_angle_changed);
slider_ypos += 8;
label_grid_angle = create_slider_label(slider_grid_angle);
int checkbox_xpos = slider_xpos;
int checkbox_ypos = slider_ypos;
int checkbox_gap = 24;
checkbox_moveballs = create_checkbox(checkbox_xpos, checkbox_ypos, "Moving Balls", is_moveballs_set);
checkbox_moveballs->func_state_changed().set(this, &Options::checkbox_moveballs_changed);
make_mapmode_menu(combo_mapmode_menu);
combo_mapmode = create_mapmode_combo_box(450, 40, combo_mapmode_menu, 0);
label_mapmode = create_combobox_label(combo_mapmode, "Map Mode");
update_all_slider_text();
func_render().set(this, &Options::on_render);
}
ColorWheel::ColorWheel(clan::Canvas &canvas, clan::GUIManager &gui, clan::Rect gui_position) : clan::GUIComponent(&gui, clan::GUITopLevelDescription("ColorWheel", gui_position, false))
{
clan::CSSValueBackgroundColor color;
color.color = clan::Colorf::black;
set_style(color, true); // We want a black background
saturation_outer = 1.0f;
saturation_inner = 0.0f;
value_outer = 1.0f;
value_inner = 0.0f;
is_hsl = false;
slider_saturation_outer = create_slider(16, 16);
slider_saturation_inner = create_slider(16, 48);
slider_value_outer = create_slider(16, 80);
slider_value_inner = create_slider(16, 112);
slider_saturation_outer->set_position(slider_saturation_outer->get_max());
slider_saturation_inner->set_position(0);
slider_value_outer->set_position(slider_value_outer->get_max());
slider_value_inner->set_position(0);
radiobutton_HSV = new clan::RadioButton(this);
radiobutton_HSV->set_geometry(clan::Rect(16, 0 , clan::Size(64, 16)));
radiobutton_HSV->set_text(" "); // ** I'm got lazy to set the text color to white, so I draw it elsewhere
radiobutton_HSV->set_selected(true);
radiobutton_HSV->set_group_name("Main Group");
radiobutton_HSV->func_selected() = bind_member(this, &ColorWheel::on_selected, radiobutton_HSV);
radiobutton_HSL = new clan::RadioButton(this);
radiobutton_HSL->set_geometry(clan::Rect(100, 0, clan::Size(64, 16)));
radiobutton_HSL->set_text(" ");
radiobutton_HSL->set_group_name("Main Group");
radiobutton_HSL->func_selected() = bind_member(this, &ColorWheel::on_selected, radiobutton_HSL);
radiobutton_HSV->set_selected(true);
func_render() = bind_member(this, &ColorWheel::on_render);
font = clan::Font(canvas, "tahoma", 16);
}
Options::Options(clan::Canvas &canvas) : clan::TextureWindow(canvas)
{
int slider_xpos = 400;
int slider_label_xpos = slider_xpos + 200;
int slider_ypos = 200;
int slider_gap = 32;
slider_outline_size = create_slider(slider_xpos, slider_ypos);
slider_outline_size->set_max_position(32);
slider_outline_size->set_position(outline_size);
slider_outline_size->func_value_changed() = bind_member(this, &Options::slider_outline_size_changed);
label_outline_size = create_slider_label(slider_label_xpos, slider_ypos);
slider_ypos += slider_gap;
slider_group_size = create_slider(slider_xpos, slider_ypos);
slider_group_size->set_max_position(1024);
slider_group_size->set_position(group_size);
slider_group_size->func_value_changed() = bind_member(this, &Options::slider_group_size_changed);
label_group_size = create_slider_label(slider_label_xpos, slider_ypos);
slider_ypos += slider_gap;
update_all_slider_text();
}
int init_panel(window_t *win)
{
button_t *btn;
progress_t *prg;
level_t *lvl;
slider_t *sld;
panel_t *panel = &win->panel;
ctx_t *ctx = &panel->ctx;
link_initialize(&panel->ctrl.link);
list_initialize(&panel->ctrl.child);
panel->ctrl.handler = panel_proc;
panel->ctrl.parent = (ctrl_t*)win;
panel->layout = 0;
panel->bitmap.width = 1920;
panel->bitmap.height = PANEL_HEIGHT;
panel->bitmap.flags = 0;
if( create_bitmap(&panel->bitmap) )
{
printf("not enough memory for panel bitmap\n");
return 0;
}
ctx->pixmap = &panel->bitmap;
ctx->offset_x = 0;
ctx->offset_y = 0;
panel->ctrl.ctx = ctx;
btn = create_button(NULL, ID_PLAY,0,19,32,32,&panel->ctrl);
panel->play_btn = btn;
btn->img_default = res_pause_btn;
btn->img_hilite = res_pause_btn;
btn->img_pressed = res_pause_btn_pressed;
btn = create_button(NULL, ID_STOP,0,19,24,24,&panel->ctrl);
panel->stop_btn = btn;
btn->img_default = res_stop_btn;
btn->img_hilite = res_stop_btn;
btn->img_pressed = res_stop_btn_pressed;
prg = create_progress(NULL,ID_PROGRESS,0,4,0,10,&panel->ctrl);
panel->prg = prg;
lvl = create_level(NULL, ID_VOL_LEVEL, 0, 20, 96, 10, &panel->ctrl);
lvl->vol = -1875;
panel->lvl = lvl;
sld = create_slider(NULL, ID_VOL_CTRL, 0, 20, 96+12, 12, &panel->ctrl);
panel->sld = sld;
// btn = create_button(NULL, ID_MINIMIZE,0,5,16,18,(ctrl_t*)cpt);
// cpt->minimize_btn = btn;
// btn->img_default = res_minimize_btn;
// btn->img_hilite = res_minimize_btn_hl;
// btn->img_pressed = res_minimize_btn_pressed;
update_panel_size(win);
return 1;
};
Options::Options(CL_GUIManager &gui, CL_Rect gui_position) : CL_GUIComponent(&gui, CL_GUITopLevelDescription("Options", gui_position, false))
{
// If you change these, you also need to change the default selected combobox item
blendfunc[0] = cl_blend_src_alpha;
blendfunc[1] = cl_blend_one_minus_src_alpha;
blendfunc[2] = cl_blend_src_alpha;
blendfunc[3] = cl_blend_one_minus_src_alpha;
blendequation[0] = cl_blend_equation_add;
blendequation[1] = cl_blend_equation_add;
logic_operation = cl_logic_op_set;
logic_operation_enabled = false;
primary_color = CL_Colorf::white;
blend_color = CL_Colorf::white;
num_balls = 4;
is_premult_alpha_set = false;
is_moveballs_set = true;
is_blending_set = true;
int slider_xpos = 400;
int slider_ypos = 200;
int slider_gap = 24;
slider_numballs = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
slider_numballs->set_max(9);
slider_numballs->set_position(4);
slider_numballs->func_value_changed().set(this, &Options::slider_numballs_changed);
slider_primary_red = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_primary_red->func_value_changed().set(this, &Options::slider_primary_red_changed);
slider_primary_green = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_primary_green->func_value_changed().set(this, &Options::slider_primary_green_changed);
slider_primary_blue = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_primary_blue->func_value_changed().set(this, &Options::slider_primary_blue_changed);
slider_primary_alpha = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_primary_alpha->func_value_changed().set(this, &Options::slider_primary_alpha_changed);
slider_ypos += 8;
slider_blend_red = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_blend_red->func_value_changed().set(this, &Options::slider_blend_red_changed);
slider_blend_green = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_blend_green->func_value_changed().set(this, &Options::slider_blend_green_changed);
slider_blend_blue = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_blend_blue->func_value_changed().set(this, &Options::slider_blend_blue_changed);
slider_blend_alpha = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_blend_alpha->func_value_changed().set(this, &Options::slider_blend_alpha_changed);
slider_ypos += 8;
label_numballs = create_slider_label(slider_numballs);
label_primary_red = create_slider_label(slider_primary_red);
label_primary_green = create_slider_label(slider_primary_green);
label_primary_blue = create_slider_label(slider_primary_blue);
label_primary_alpha = create_slider_label(slider_primary_alpha);
label_blend_red = create_slider_label(slider_blend_red);
label_blend_green = create_slider_label(slider_blend_green);
label_blend_blue = create_slider_label(slider_blend_blue);
label_blend_alpha = create_slider_label(slider_blend_alpha);
int checkbox_xpos = slider_xpos;
int checkbox_ypos = slider_ypos;
int checkbox_gap = 24;
checkbox_moveballs = create_checkbox(checkbox_xpos, checkbox_ypos, "Moving Balls", is_moveballs_set);
checkbox_moveballs->func_state_changed().set(this, &Options::checkbox_moveballs_changed);
checkbox_blending = create_checkbox(checkbox_xpos + 150, checkbox_ypos, "Enable Blending", is_blending_set);
checkbox_blending->func_state_changed().set(this, &Options::checkbox_blending_changed);
checkbox_premult_alpha = create_checkbox(checkbox_xpos + 300, checkbox_ypos, "Use Premultipied Alpha", is_premult_alpha_set);
checkbox_premult_alpha->func_state_changed().set(this, &Options::checkbox_premult_alpha_changed);
checkbox_ypos += checkbox_gap + 8;
make_equation_menu(combo_color_equation_menu);
make_equation_menu(combo_alpha_equation_menu);
combo_color_equation = create_equation_combo_box(400, 40, combo_color_equation_menu, 0);
combo_alpha_equation = create_equation_combo_box(550, 40, combo_alpha_equation_menu, 0);
label_color = create_combobox_label(combo_color_equation, "COLOR EQUATION");
label_alpha = create_combobox_label(combo_alpha_equation, "ALPHA EQUATION");
make_logic_menu(combo_logic_menu);
combo_logic = create_logic_combo_box(700, 40, combo_logic_menu, 0);
label_logic = create_combobox_label(combo_logic, "LOGIC OPERATION");
make_blend_menu(combo_src_blend_menu);
make_blend_menu(combo_dest_blend_menu);
make_blend_menu(combo_src_alpha_blend_menu);
make_blend_menu(combo_dest_alpha_blend_menu);
combo_src_blend = create_blend_combo_box(410, 100, combo_src_blend_menu, 6);
label_src = create_combobox_label(combo_src_blend, "SOURCE FUNCTION");
combo_dest_blend = create_blend_combo_box(610, 100, combo_dest_blend_menu, 7);
label_dest = create_combobox_label(combo_dest_blend, "DEST FUNCTION");
combo_src_alpha_blend = create_blend_combo_box(410, 160, combo_src_alpha_blend_menu, 6);
label_src_alpha = create_combobox_label(combo_src_alpha_blend, "SOURCE ALPHA FUNCTION");
combo_dest_alpha_blend = create_blend_combo_box(610, 160, combo_dest_alpha_blend_menu, 7);
label_dest_alpha = create_combobox_label(combo_dest_alpha_blend, "DEST ALPHA FUNCTION");
update_all_slider_text();
func_render().set(this, &Options::on_render);
}
/** \brief Create slider for ReSID 8580 filter bias
*
* \param[in] minimal resize slider to minimal size
*
* \return GtkScale
*/
static GtkWidget *create_bias8580_widget(gboolean minimal)
{
return create_slider("SidResid8580FilterBias", -5000, 5000, 1000, minimal);
}
/** \brief Create slider for ReSID 8580 gain
*
* \param[in] minimal resize slider to minimal size
*
* \return GtkScale
*/
static GtkWidget *create_gain8580_widget(gboolean minimal)
{
return create_slider("SidResid8580Gain", 90, 100, 1, minimal);
}
/** \brief Create slider for ReSID 8580 passband
*
* \param[in] minimal resize slider to minimal size
*
* \return GtkScale
*/
static GtkWidget *create_passband8580_widget(gboolean minimal)
{
return create_slider("SidResid8580PassBand", 0, 90, 5, minimal);
}
/** \brief Create slider for main volume
*
* \param[in] minimal resize slider to minimal size
*
* \return GtkScale
*/
static GtkWidget *create_volume_widget(gboolean minimal)
{
return create_slider("SoundVolume", 0, 100, 5, minimal);
}
void update_slider(GuiObject * obj)
{
check_object(obj, "obj", "update_slider");
create_slider(obj);
}
Options::Options(CL_GUIManager &gui, CL_Rect gui_position) : CL_GUIComponent(&gui, CL_GUITopLevelDescription("Options", gui_position, false))
{
// Note, when changing these, remember to change the popup menu defaults
selected_light = light_spot;
max_color_value = 4.0f;
max_angle_value = 360.0f;
max_exponent_value = 5.0f;
max_position_value = 100.0f;
spot_light_position.x = max_position_value / 2.0f;
spot_light_position.y = max_position_value / 2.0f;
spot_light_position.z = max_position_value / 2.0f;
spot_light_cutoff = 30.0f;
spot_light_exponent = 0.5f;
distant_specular_color = CL_Colorf(0.5f, 0.5f, 0.5f, 1.0f);
distant_diffuse_color = CL_Colorf(0.5f, 0.5f, 0.5f, 1.0f);
spot_specular_color = CL_Colorf(1.0f, 0.0f, 0.0f, 1.0f);
spot_diffuse_color = CL_Colorf(1.0f, 0.0f, 0.0f, 1.0f);
distant_direction_heading = CL_Angle(45.0f, cl_degrees);
distant_direction_pitch = CL_Angle(35.0f, cl_degrees);
distant_direction_bank = CL_Angle(0.0f, cl_degrees);
spot_direction_heading = CL_Angle(129.6f, cl_degrees);
spot_direction_pitch = CL_Angle(123.8f, cl_degrees);
spot_direction_bank = CL_Angle(0.0f, cl_degrees);
make_light_menu(combo_light_menu);
combo_light = create_light_combo_box(8, 16, combo_light_menu, 1);
label_light = create_combobox_label(combo_light, "Selected Light");
int slider_xpos = 8;
int slider_ypos = 48;
int slider_gap = 24;
slider_ypos += 8;
slider_diffuse_red = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_diffuse_red->func_value_changed().set(this, &Options::slider_diffuse_red_changed);
slider_diffuse_green = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_diffuse_green->func_value_changed().set(this, &Options::slider_diffuse_green_changed);
slider_diffuse_blue = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_diffuse_blue->func_value_changed().set(this, &Options::slider_diffuse_blue_changed);
label_diffuse_red = create_slider_label(slider_diffuse_red);
label_diffuse_green = create_slider_label(slider_diffuse_green);
label_diffuse_blue = create_slider_label(slider_diffuse_blue);
slider_ypos += 8;
slider_specular_red = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_specular_red->func_value_changed().set(this, &Options::slider_specular_red_changed);
slider_specular_green = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_specular_green->func_value_changed().set(this, &Options::slider_specular_green_changed);
slider_specular_blue = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_specular_blue->func_value_changed().set(this, &Options::slider_specular_blue_changed);
label_specular_red = create_slider_label(slider_specular_red);
label_specular_green = create_slider_label(slider_specular_green);
label_specular_blue = create_slider_label(slider_specular_blue);
slider_ypos += 8;
slider_direction_heading = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_direction_heading->func_value_changed().set(this, &Options::slider_direction_heading_changed);
slider_direction_pitch = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_direction_pitch->func_value_changed().set(this, &Options::slider_direction_pitch_changed);
slider_direction_bank = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_direction_bank->func_value_changed().set(this, &Options::slider_direction_bank_changed);
label_direction_heading = create_slider_label(slider_direction_heading);
label_direction_pitch = create_slider_label(slider_direction_pitch);
label_direction_bank = create_slider_label(slider_direction_bank);
slider_ypos += 8;
slider_light_xpos = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_light_xpos->func_value_changed().set(this, &Options::slider_light_xpos_changed);
slider_light_ypos = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_light_ypos->func_value_changed().set(this, &Options::slider_light_ypos_changed);
slider_light_zpos = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_light_zpos->func_value_changed().set(this, &Options::slider_light_zpos_changed);
slider_cutoff = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_cutoff->func_value_changed().set(this, &Options::slider_cutoff_changed);
slider_exponent = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_exponent->func_value_changed().set(this, &Options::slider_exponent_changed);
label_light_xpos = create_slider_label(slider_light_xpos);
label_light_ypos = create_slider_label(slider_light_ypos);
label_light_zpos = create_slider_label(slider_light_zpos);
label_cutoff = create_slider_label(slider_cutoff);
label_exponent = create_slider_label(slider_exponent);
set_all_sliders();
func_render().set(this, &Options::on_render);
}
void henon_tweaker(void)
{
int i;
char chosen_file[128];
rect R;
rect tR;
int last_time;
int keyword;
int current_item;
int centerx, centery;
int height, width;
int row;
static int lefters[] = {
1, 2, 0,
4, 3,
5,
12, 6, 7, 8, 9, 10, 11,
15, 13, 14
};
static int righters[] = {
1, 2, 0,
4, 3,
5,
7, 8, 9, 10, 11, 12, 6,
14, 15, 13
};
static int uppers[] = {
13, 14, 15,
0, 2,
3,
5, 5, 5, 5, 5, 5, 5,
6, 8, 11
};
static int downers[] = {
3, 3, 4,
5, 5,
8,
13, 13, 13, 14, 14, 15, 15,
0, 1, 2
};
our_flocktype = flocktype;
our_tracetype = tracetype;
henon_slider.value = fha;
height = 2 + FontHeight + 8 +
2 * (3 * FontHeight / 2) +
slider_height(&henon_slider) + 4
+ 2 * FontHeight + 4;
width = 2 * sR.Xmax / 3;
HideCursor();
PushCursorPosition();
BasicCenteredBox(&tR, width, height, LIGHTGRAY, "H non Tweaks", BLACK);
Centers(&tR, ¢erx, ¢ery);
PushMouseRectLimit(&tR);
items = 0;
R.Xmin = tR.Xmin + 4 + StringWidth("Flock Size: ") + 4;
R.Xmax = tR.Xmax - 4;
R.Ymin = row = tR.Ymin + FontHeight + 8;
R.Ymax = R.Ymin + FontHeight + 4;
JString("Flock size: ", R.Xmin - 2, R.Ymin + 2, BLACK, LIGHTGRAY, alignRight, alignTop);
CreateRadioPanel(&R, SML, flocktypeR, 3, our_flocktype);
for (i = 0; i < 3; i++)
bR[items++] = &flocktypeR[i];
OffsetRect(&R, 0, 3 * FontHeight / 2);
R.Xmin = centerx;
row = R.Ymin;
JString("Trace Type: ", R.Xmin - 2, R.Ymin + 2, BLACK, LIGHTGRAY, alignRight, alignTop);
CreateRadioPanel(&R, PL, tracetypeR, 2, our_tracetype);
for (i = 0; i < 2; i++)
bR[items++] = &tracetypeR[i];
row += 3 * FontHeight / 2;
create_slider(&henon_slider, &tR, 4, row - tR.Ymin);
bR[items++] = &henon_slider.bR;
bR[items++] = &henon_slider.TB.nR;
for (i = 0; i < 6; i++)
bR[items++] = &henon_slider.zR[i];
if (!fancyflag)
{
R = henon_slider.tR;
InsetRect(&R, 1, 1);
GrayOut(&R);
}
row = henon_slider.tR.Ymax + FontHeight;
R.Xmin = tR.Xmin + 4;
R.Xmax = tR.Xmax - 4;
R.Ymin = row;
R.Ymax = row + FontHeight + 4;
CreateRadioPanel(&R, standard_button_texts, doitR, 3, -1);
for (i = 0; i < 3; i++)
bR[items++] = &doitR[i];
current_item = items - 1;
push(current_item, true);
move_to_corner(bR[current_item]);
ShowCursor();
while (1)
{
event e;
int n = KeyEvent(false, &e);
int button = (e.State & 0x700) >> 8;
int X = e.CursorX;
int Y = e.CursorY;
int last_item = current_item;
slider *current_slider = NULL;
if (fancyflag && XYInRect(X, Y, &henon_slider.tR))
current_slider = &henon_slider;
keyword = 0;
if (n)
last_time = e.Time;
else
{
if (e.Time - last_time > 5)
{
if (button)
n = 1;
else
last_time = e.Time;
}
}
if (n)
{
keyword = ShiftArrows(&e);
if (button == swRight)
keyword = 0x1b;
if (!keyword)
{
if (e.ASCII && e.ASCII != 0xe0)
keyword = e.ASCII;
else
keyword = e.ScanCode << 8;
}
if (button == swLeft)
{
keyword = 0x0d;
if (current_slider)
{
if (XYInRect(X, Y, ¤t_slider->bR))
{
PushMouseRectLimit(¤t_slider->sR);
while (button == swLeft)
{
reposition_slider_X(current_slider, X, false);
KeyEvent(false, &e);
button = (e.State & 0x700) >> 8;
X = e.CursorX;
Y = e.CursorY;
}
PopMouseRect();
keyword = 0;
}
else if (XYInRect(X, Y, ¤t_slider->sR))
{
reposition_slider_X(current_slider, X, false);
keyword = 0;
}
}
}
Options::Options(clan::GUIManager &gui, clan::Rect gui_position) : clan::GUIComponent(&gui, clan::GUITopLevelDescription("Options", gui_position, false))
{
is_normals_set = false;
sized_format = clan::tf_rgb8;
dimension = perlin_2d;
amplitude = 1.0;
width = 256;
height = 256;
octaves = 1;
start_x = 0.0f;
length_x = 32.0f;
start_y = 0.0f;
length_y = 32.0f;
position_z = 0.0f;
position_w = 0.0f;
make_format_menu(combo_format_menu);
combo_format = create_format_combo_box(450, 30, combo_format_menu, 0);
label_format = create_combobox_label(combo_format, "Pixel Format");
checkbox_normals = create_checkbox(640, 35, "Draw Normals (rgb only)", is_normals_set);
checkbox_normals->func_state_changed().set(this, &Options::checkbox_normals_changed);
make_dimension_menu(combo_dimension_menu);
combo_dimension = create_dimension_combo_box(450, 80, combo_dimension_menu, 0);
combo_dimension->set_selected_item(1);
label_dimension = create_combobox_label(combo_dimension, "Dimension");
int slider_xpos = 450;
int slider_ypos = 120;
int slider_gap = 20;
slider_width = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
slider_width->set_min(32);
slider_width->set_max(382);
slider_width->set_position(width);
slider_width->func_value_changed().set(this, &Options::slider_width_changed);
slider_ypos += 8;
label_width = create_slider_label(slider_width);
slider_height = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
slider_height->set_min(32);
slider_height->set_max(382);
slider_height->set_position(height);
slider_height->func_value_changed().set(this, &Options::slider_height_changed);
slider_ypos += 8;
label_height = create_slider_label(slider_height);
slider_octaves = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
slider_octaves->set_min(1);
slider_octaves->set_max(9);
slider_octaves->set_page_step(1);
slider_octaves->set_position(octaves);
slider_octaves->func_value_changed().set(this, &Options::slider_octaves_changed);
slider_ypos += 8;
label_octaves = create_slider_label(slider_octaves);
slider_amplitude = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
set_value(slider_amplitude, amplitude, MAX_AMPLITUDE);
slider_amplitude->func_value_changed().set(this, &Options::slider_amplitude_changed);
slider_ypos += 8;
label_amplitude = create_slider_label(slider_amplitude);
slider_start_x = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
set_value(slider_start_x, start_x, MAX_POSITION);
slider_start_x->func_value_changed().set(this, &Options::slider_start_x_changed);
slider_ypos += 8;
label_start_x = create_slider_label(slider_start_x);
slider_length_x = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
set_value(slider_length_x, length_x, MAX_LENGTH);
slider_length_x->func_value_changed().set(this, &Options::slider_length_x_changed);
slider_ypos += 8;
label_length_x = create_slider_label(slider_length_x);
slider_start_y = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
set_value(slider_start_y, start_y, MAX_POSITION);
slider_start_y->func_value_changed().set(this, &Options::slider_start_y_changed);
slider_ypos += 8;
label_start_y = create_slider_label(slider_start_y);
slider_length_y = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
set_value(slider_length_y, length_y, MAX_LENGTH);
slider_length_y->func_value_changed().set(this, &Options::slider_length_y_changed);
slider_ypos += 8;
label_length_y = create_slider_label(slider_length_y);
slider_position_z = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
set_value(slider_position_z, position_z, MAX_POSITION);
slider_position_z->func_value_changed().set(this, &Options::slider_position_z_changed);
slider_ypos += 8;
label_position_z = create_slider_label(slider_position_z);
slider_position_w = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_ypos += 8;
set_value(slider_position_w, position_w, MAX_POSITION);
slider_position_w->func_value_changed().set(this, &Options::slider_position_w_changed);
slider_ypos += 8;
label_position_w = create_slider_label(slider_position_w);
update_all_slider_text();
func_render().set(this, &Options::on_render);
}
GtkWidget* ctk_xvideo_new(NvCtrlAttributeHandle *handle,
CtkConfig *ctk_config,
CtkEvent *ctk_event)
{
GObject *object;
CtkXVideo *ctk_xvideo;
GtkWidget *banner;
GtkWidget *frame;
GtkWidget *alignment;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *button;
int sync_mask;
int xv_overlay_present, xv_texture_present, xv_blitter_present;
ReturnStatus ret;
/*
* before we do anything else, determine if any of the Xv adapters
* are present
*/
ret = NvCtrlGetAttribute(handle, NV_CTRL_ATTR_EXT_XV_OVERLAY_PRESENT,
&xv_overlay_present);
if (ret != NvCtrlSuccess) xv_overlay_present = FALSE;
ret = NvCtrlGetAttribute(handle, NV_CTRL_ATTR_EXT_XV_TEXTURE_PRESENT,
&xv_texture_present);
if (ret != NvCtrlSuccess) xv_texture_present = FALSE;
ret = NvCtrlGetAttribute(handle, NV_CTRL_ATTR_EXT_XV_BLITTER_PRESENT,
&xv_blitter_present);
if (ret != NvCtrlSuccess) xv_blitter_present = FALSE;
if (!xv_overlay_present && !xv_texture_present && !xv_blitter_present) {
return NULL;
}
/* create the XVideo widget */
object = g_object_new(CTK_TYPE_XVIDEO, NULL);
ctk_xvideo = CTK_XVIDEO(object);
ctk_xvideo->handle = handle;
ctk_xvideo->ctk_config = ctk_config;
ctk_xvideo->active_attributes = 0;
gtk_box_set_spacing(GTK_BOX(ctk_xvideo), 10);
/* Create button, but don't pack it, yet */
label = gtk_label_new("Reset Hardware Defaults");
hbox = gtk_hbox_new(FALSE, 0);
button = gtk_button_new();
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 15);
gtk_container_add(GTK_CONTAINER(button), hbox);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(reset_defaults), (gpointer) ctk_xvideo);
ctk_config_set_tooltip(ctk_config, button, __reset_button_help);
/* Video film banner */
banner = ctk_banner_image_new(BANNER_ARTWORK_XVIDEO);
gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0);
/* XVideo Overlay sliders */
if (xv_overlay_present) {
frame = gtk_frame_new("Video Overlay Adaptor");
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
ctk_xvideo->overlay_saturation =
create_slider(ctk_xvideo, vbox, button, "Saturation",
__xv_overlay_saturation_help,
NV_CTRL_ATTR_XV_OVERLAY_SATURATION,
__XV_OVERLAY_SATURATION);
ctk_xvideo->overlay_contrast =
create_slider(ctk_xvideo, vbox, button, "Contrast",
__xv_overlay_contrast_help,
NV_CTRL_ATTR_XV_OVERLAY_CONTRAST,
__XV_OVERLAY_CONTRAST);
ctk_xvideo->overlay_brightness =
create_slider(ctk_xvideo, vbox, button, "Brightness",
__xv_overlay_brightness_help,
NV_CTRL_ATTR_XV_OVERLAY_BRIGHTNESS,
__XV_OVERLAY_BRIGHTNESS);
ctk_xvideo->overlay_hue =
create_slider(ctk_xvideo, vbox, button, "Hue",
__xv_overlay_hue_help,
NV_CTRL_ATTR_XV_OVERLAY_HUE,
__XV_OVERLAY_HUE);
}
/* XVideo Texture */
if (xv_texture_present) {
frame = gtk_frame_new("Video Texture Adaptor");
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
ctk_xvideo->texture_sync_to_blank =
create_check_button(ctk_xvideo, vbox, button, "Sync to VBlank",
__xv_texture_sync_to_vblank_help,
NV_CTRL_ATTR_XV_TEXTURE_SYNC_TO_VBLANK,
__XV_TEXTURE_SYNC_TO_VBLANK);
ctk_xvideo->texture_brightness =
create_slider(ctk_xvideo, vbox, button, "Brightness",
__xv_texture_brightness_help,
NV_CTRL_ATTR_XV_TEXTURE_BRIGHTNESS,
__XV_TEXTURE_BRIGHTNESS);
ctk_xvideo->texture_contrast =
create_slider(ctk_xvideo, vbox, button, "Contrast",
__xv_texture_contrast_help,
NV_CTRL_ATTR_XV_TEXTURE_CONTRAST,
__XV_TEXTURE_CONTRAST);
ctk_xvideo->texture_hue =
create_slider(ctk_xvideo, vbox, button, "Hue",
__xv_texture_hue_help,
NV_CTRL_ATTR_XV_TEXTURE_HUE,
__XV_TEXTURE_HUE);
ctk_xvideo->texture_saturation =
create_slider(ctk_xvideo, vbox, button, "Saturation",
__xv_texture_saturation_help,
NV_CTRL_ATTR_XV_TEXTURE_SATURATION,
__XV_TEXTURE_SATURATION);
}
/* XVideo Blitter */
if (xv_blitter_present) {
frame = gtk_frame_new("Video Blitter Adaptor Settings");
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
ctk_xvideo->blitter_sync_to_blank =
create_check_button(ctk_xvideo,
vbox,
button,
"Sync to VBlank",
__xv_blitter_sync_to_vblank_help,
NV_CTRL_ATTR_XV_BLITTER_SYNC_TO_VBLANK,
__XV_BLITTER_SYNC_TO_VBLANK);
}
/* Sync to display selection */
if (xv_texture_present || xv_blitter_present) {
ret = NvCtrlGetAttribute(handle,
NV_CTRL_XV_SYNC_TO_DISPLAY,
&sync_mask);
if (ret == NvCtrlSuccess) {
int enabled;
ret = NvCtrlGetAttribute(handle,
NV_CTRL_ENABLED_DISPLAYS,
&enabled);
if (ret == NvCtrlSuccess) {
GtkWidget *radio[24], *prev_radio;
int i, n, current = -1, mask;
char *name, *type;
gchar *name_str;
frame = gtk_frame_new("Sync to this display device");
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
ctk_xvideo->xv_sync_to_display_button_box = vbox;
for (n=0, i = 0; i < 24; i++) {
mask = 1 << i;
if (!(enabled & mask)) continue;
/* get the name of the display device */
ret = NvCtrlGetStringDisplayAttribute(handle, mask,
NV_CTRL_STRING_DISPLAY_DEVICE_NAME,
&name);
if ((ret != NvCtrlSuccess) || (!name)) {
name = g_strdup("Unknown");
}
/* get the display device type */
type = display_device_mask_to_display_device_name(mask);
name_str = g_strdup_printf("%s (%s)", name, type);
XFree(name);
free(type);
if (n==0) {
prev_radio = NULL;
} else {
prev_radio = radio[n-1];
}
radio[n] = xv_sync_to_display_radio_button_add(ctk_xvideo,
prev_radio,
name_str,
mask, n);
g_free(name_str);
ctk_config_set_tooltip(ctk_config, radio[n],
__xv_sync_to_display_help);
if (mask == sync_mask) {
current = n;
}
n++;
ctk_xvideo->active_attributes |= __XV_SYNC_TO_DISPLAY;
}
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_XV_SYNC_TO_DISPLAY),
G_CALLBACK(xv_sync_to_display_update_received),
(gpointer) ctk_xvideo);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_ENABLED_DISPLAYS),
G_CALLBACK(nv_ctrl_enabled_displays),
(gpointer) ctk_xvideo);
sensitize_radio_buttons(ctk_xvideo);
if (current != -1)
xv_sync_to_display_update_radio_buttons(ctk_xvideo, current);
}
}
}
/* Reset button */
sensitize_radio_buttons(ctk_xvideo);
alignment = gtk_alignment_new(1, 1, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment), button);
gtk_box_pack_start(GTK_BOX(object), alignment, TRUE, TRUE, 0);
/* finally, show the widget */
gtk_widget_show_all(GTK_WIDGET(ctk_xvideo));
return GTK_WIDGET(ctk_xvideo);
} /* ctk_xvideo_new() */
Options::Options(GUIManager &gui, Rect gui_position) : GUIComponent(&gui, GUITopLevelDescription("Options", gui_position, false))
{
button_lerp_clicked = false;
button_slerp_clicked = false;
button_rotate_clicked = false;
max_angle_value = 360.0f;
rotation_x = Angle(0.0f, angle_degrees);
rotation_y = Angle(0.0f, angle_degrees);
rotation_z = Angle(0.0f, angle_degrees);
target_x = Angle(0.0f, angle_degrees);
target_y = Angle(0.0f, angle_degrees);
target_z = Angle(0.0f, angle_degrees);
int slider_xpos = 8;
int slider_ypos = 8;
int slider_gap = 24;
slider_rotation_y = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_rotation_y->func_value_changed().set(this, &Options::slider_rotation_y_changed);
slider_rotation_x = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_rotation_x->func_value_changed().set(this, &Options::slider_rotation_x_changed);
slider_rotation_z = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_rotation_z->func_value_changed().set(this, &Options::slider_rotation_z_changed);
label_rotation_y = create_slider_label(slider_rotation_y);
label_rotation_x = create_slider_label(slider_rotation_x);
label_rotation_z = create_slider_label(slider_rotation_z);
slider_xpos = 300;
slider_ypos = 8;
slider_quaternion_w = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_quaternion_w->func_value_changed().set(this, &Options::slider_quaternion_w_changed);
label_quaternion_w = create_slider_label(slider_quaternion_w);
slider_quaternion_i = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_quaternion_i->func_value_changed().set(this, &Options::slider_quaternion_i_changed);
label_quaternion_i = create_slider_label(slider_quaternion_i);
slider_quaternion_j = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_quaternion_j->func_value_changed().set(this, &Options::slider_quaternion_j_changed);
label_quaternion_j = create_slider_label(slider_quaternion_j);
slider_quaternion_k = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_quaternion_k->func_value_changed().set(this, &Options::slider_quaternion_k_changed);
label_quaternion_k = create_slider_label(slider_quaternion_k);
slider_xpos = 600;
slider_ypos = 8;
slider_target_y = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_target_y->func_value_changed().set(this, &Options::slider_target_y_changed);
slider_target_x = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_target_x->func_value_changed().set(this, &Options::slider_target_x_changed);
slider_target_z = create_slider(slider_xpos, slider_ypos); slider_ypos += slider_gap;
slider_target_z->func_value_changed().set(this, &Options::slider_target_z_changed);
label_target_y = create_slider_label(slider_target_y);
label_target_x = create_slider_label(slider_target_x);
label_target_z = create_slider_label(slider_target_z);
slider_xpos = 8;
slider_ypos = 120;
button_lerp = new PushButton(this);
button_lerp->set_geometry(Rect(slider_xpos, slider_ypos, Size(256, 30)));
button_lerp->set_text("Linear Quaternion Interpolation (lerp)");
button_lerp->func_clicked().set(this, &Options::on_clicked_button_lerp);
slider_xpos += 300;
button_slerp = new PushButton(this);
button_slerp->set_geometry(Rect(slider_xpos, slider_ypos, Size(256, 30)));
button_slerp->set_text("Spherical Linear Interpolation (slerp)");
button_slerp->func_clicked().set(this, &Options::on_clicked_button_slerp);
slider_xpos += 300;
button_rotate = new PushButton(this);
button_rotate->set_geometry(Rect(slider_xpos, slider_ypos, Size(256, 30)));
button_rotate->set_text("Rotate : q.multiply(target)");
button_rotate->func_clicked().set(this, &Options::on_clicked_button_rotate);
set_all_sliders();
func_render().set(this, &Options::on_render);
}
