GtkWidget * scaler_new(gdouble low, gdouble high, gdouble prec)
{
GtkWidget * w;
w = gtk_hscale_new_with_range(low,high,prec);
gtk_scale_set_value_pos(GTK_SCALE(w),GTK_POS_RIGHT);
gtk_range_set_update_policy(GTK_RANGE(w),GTK_UPDATE_DISCONTINUOUS);
gtk_widget_set_size_request(w,100,-1);
return w;
}
/*
* @brief creates all GTK+ widgets that compose the player & sets up callbacks
* */
static void create_ui(CustomData *data) {
GtkWidget *main_window; /* uppermost container window */
GtkWidget *video_window; /* video is shown here */
GtkWidget *main_box; /* holds hbox & controls */
GtkWidget *main_hbox; /* hold video window & streaminfo widget */
GtkWidget *controls; /* hold buttons & slider */
GtkWidget *play_button, *pause_button, *stop_button;
GtkCellRenderer *renderer;
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(main_window), "delete-event", G_CALLBACK(delete_event_cb), data);
video_window = gtk_drawing_area_new();
gtk_widget_set_double_buffered(video_window, FALSE);
g_signal_connect(G_OBJECT(video_window), "realize", G_CALLBACK(realise_cb), data);
g_signal_connect (video_window, "expose_event", G_CALLBACK (expose_cb), data);
play_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PLAY);
g_signal_connect (G_OBJECT (play_button), "clicked", G_CALLBACK (play_cb), data);
pause_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PAUSE);
g_signal_connect (G_OBJECT (pause_button), "clicked", G_CALLBACK (pause_cb), data);
stop_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_STOP);
g_signal_connect (G_OBJECT (stop_button), "clicked", G_CALLBACK (stop_cb), data);
data->slider = gtk_hscale_new_with_range(0, 100, 1);
gtk_scale_set_draw_value(GTK_SCALE(data->slider), 0);
data->slider_update_signal_id = g_signal_connect (G_OBJECT (data->slider), "value-changed", G_CALLBACK (slider_cb), data);
data->streams_list = gtk_tree_view_new();
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_fixed_size(renderer, 15, -1);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(data->streams_list),
-1, "Stream Name", renderer, "text", COL_STREAM_NAME, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_fixed_size(renderer, 15, -1);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(data->streams_list),
-1, "Stream Details", renderer, "text", COL_STREAM_DETAILS, NULL);
g_signal_connect(data->streams_list, "row-activated", G_CALLBACK(stream_select_cb), data);
//gtk_text_view_set_editable (GTK_TEXT_VIEW (data->streams_list), FALSE);
controls = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (controls), play_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (controls), pause_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (controls), stop_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (controls), data->slider, TRUE, TRUE, 2);
main_box = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (main_box), video_window, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (main_box), data->streams_list, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (main_box), controls, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (main_window), main_box);
gtk_window_set_default_size (GTK_WINDOW (main_window), 640, 480);
gtk_widget_show_all (main_window);
}
void HorizontalSlider::create(Window &parent, unsigned x, unsigned y, unsigned width, unsigned height, unsigned length) {
object->position = 0;
length += (length == 0);
object->widget = gtk_hscale_new_with_range(0, length - 1, 1);
gtk_scale_set_draw_value(GTK_SCALE(object->widget), false);
gtk_widget_set_size_request(object->widget, width, height);
g_signal_connect_swapped(G_OBJECT(object->widget), "value-changed", G_CALLBACK(HorizontalSlider_change), (gpointer)this);
gtk_fixed_put(GTK_FIXED(parent.object->formContainer), object->widget, x, y);
gtk_widget_show(object->widget);
}
/** create a control for float ports */
static GtkWidget *
create_float_control (plugin_desc_t * desc, unsigned long port_index)
{
LADSPA_Data lower;
LADSPA_Data upper;
GtkWidget *widget;
if (LADSPA_IS_HINT_SAMPLE_RATE (desc->port_range_hints[port_index].HintDescriptor))
{
lower =
desc->port_range_hints[port_index].LowerBound *
(LADSPA_Data) sample_rate;
upper =
desc->port_range_hints[port_index].UpperBound *
(LADSPA_Data) sample_rate;
}
else
{
lower = desc->port_range_hints[port_index].LowerBound;
upper = desc->port_range_hints[port_index].UpperBound;
}
if (!LADSPA_IS_HINT_BOUNDED_BELOW
(desc->port_range_hints[port_index].HintDescriptor))
{
lower = (LADSPA_Data) - 100.0;
}
if (!LADSPA_IS_HINT_BOUNDED_ABOVE
(desc->port_range_hints[port_index].HintDescriptor))
{
upper = (LADSPA_Data) 100.0;
}
if (LADSPA_IS_HINT_LOGARITHMIC (desc->port_range_hints[port_index].HintDescriptor))
{
if (lower < FLT_EPSILON)
lower = FLT_EPSILON;
lower = log (lower);
upper = log (upper);
}
widget = gtk_hscale_new_with_range ((gdouble) lower, (gdouble) upper, (upper - lower) / 10.0);
gtk_scale_set_draw_value (GTK_SCALE (widget), FALSE);
gtk_scale_set_digits (GTK_SCALE (widget), 8);
gtk_range_set_increments (GTK_RANGE (widget), (upper - lower) / 1000.0,
(upper - lower) / 10.0);
g_assert (widget != NULL);
return widget;
}
GtkWidget *widget_hscale_create(
AttributeSet *Attr, tag_attr *attr, gint Type)
{
GtkWidget *widget;
gdouble range_min = 0;
gdouble range_max = 100;
gdouble range_step = 1;
gdouble range_value = 0;
gchar *value;
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Entering.\n", __func__);
#endif
/* Thunor: These "range-*" names are consistent with the spinbutton widget */
if (attr) {
if (!(value = get_tag_attribute(attr, "range-min")))
value = get_tag_attribute(attr, "scale-min");
if (value) range_min = atof(value);
if (!(value = get_tag_attribute(attr, "range-max")))
value = get_tag_attribute(attr, "scale-max");
if (value) range_max = atof(value);
if (!(value = get_tag_attribute(attr, "range-step")))
value = get_tag_attribute(attr, "scale-step");
if (value) range_step = atof(value);
if (!(value = get_tag_attribute(attr, "range-value")))
value = get_tag_attribute(attr, "scale-value");
if (value) range_value = atof(value);
}
if (Type == WIDGET_HSCALE) {
#if !GTK_CHECK_VERSION(3,0,0) /* gtk3: Deprecated in gtk3 so I've added the newly recommended equivalent */
widget = gtk_hscale_new_with_range(range_min, range_max, range_step);
#else
widget = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, range_min, range_max, range_step);
#endif
} else {
#if !GTK_CHECK_VERSION(3,0,0) /* gtk3: Deprecated in gtk3 so I've added the newly recommended equivalent */
widget = gtk_vscale_new_with_range(range_min, range_max, range_step);
#else
widget = gtk_scale_new_with_range(GTK_ORIENTATION_VERTICAL, range_min, range_max, range_step);
#endif
}
gtk_range_set_value(GTK_RANGE(widget), range_value);
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Exiting.\n", __func__);
#endif
return widget;
}
GtkWidget * scaler_new(gdouble low, gdouble high, gdouble prec)
{
GtkWidget * w;
#if GTK_CHECK_VERSION(3, 2, 0)
w = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL,low,high,prec);
#else
w = gtk_hscale_new_with_range(low,high,prec);
#endif
gtk_scale_set_value_pos(GTK_SCALE(w),GTK_POS_RIGHT);
gtk_widget_set_size_request(w,100,-1);
return w;
}
static void
run_gui (const gchar * filename)
{
GtkWidget *vbox, *hbox;
AppInfo *info;
info = g_new0 (AppInfo, 1);
/* create pipeline */
if (!create_pipeline (info, filename))
goto done;
/* create window */
info->win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (info->win, "delete-event", G_CALLBACK (gtk_main_quit),
NULL);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_container_add (GTK_CONTAINER (info->win), vbox);
info->img = gtk_image_new ();
gtk_box_pack_start (GTK_BOX (vbox), info->img, FALSE, FALSE, 6);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 6);
info->accurate_cb = gtk_check_button_new_with_label ("accurate seek "
"(might not work reliably with all demuxers)");
gtk_box_pack_start (GTK_BOX (hbox), info->accurate_cb, FALSE, FALSE, 6);
g_signal_connect (info->accurate_cb, "toggled",
G_CALLBACK (accurate_toggled_cb), info);
info->slider = gtk_hscale_new_with_range (0.0, 1.0, 0.001);
gtk_box_pack_start (GTK_BOX (vbox), info->slider, FALSE, FALSE, 6);
g_signal_connect (info->slider, "value-changed",
G_CALLBACK (slider_cb), info);
g_signal_connect (info->slider, "format-value",
G_CALLBACK (slider_format_value_cb), info);
/* and go! */
gst_element_set_state (info->pipe, GST_STATE_PAUSED);
gtk_widget_show_all (info->win);
gtk_widget_hide (info->slider); /* hide until we're prerolled */
gtk_main ();
done:
g_free (info);
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_tool_lighttable_t *d = (dt_lib_tool_lighttable_t *)g_malloc(sizeof(dt_lib_tool_lighttable_t));
self->data = (void *)d;
memset(d,0,sizeof(dt_lib_tool_lighttable_t));
self->widget = gtk_hbox_new(FALSE,2);
GtkWidget* widget;
/* create layout selection combobox */
widget = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(widget), _("zoomable light table"));
gtk_combo_box_append_text(GTK_COMBO_BOX(widget), _("file manager"));
gtk_combo_box_set_active(GTK_COMBO_BOX(widget), dt_conf_get_int("plugins/lighttable/layout"));
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (_lib_lighttable_layout_changed),
(gpointer)self);
gtk_box_pack_start(GTK_BOX(self->widget), widget, TRUE, TRUE, 0);
/* create horizontal zoom slider */
d->zoom = gtk_hscale_new_with_range(1, 26, 1);
gtk_widget_set_size_request (GTK_WIDGET(d->zoom), 160, -1);
gtk_scale_set_draw_value(GTK_SCALE(d->zoom), FALSE);
gtk_box_pack_start(GTK_BOX(self->widget), d->zoom, TRUE, TRUE, 0);
/* manual entry of the zoom level */
d->zoom_entry = gtk_entry_new();
gtk_entry_set_alignment(GTK_ENTRY(d->zoom_entry), 1.0);
gtk_entry_set_max_length(GTK_ENTRY(d->zoom_entry), 2);
g_object_set(G_OBJECT(d->zoom_entry), "width-chars", 3, (char *)NULL);
dt_gui_key_accel_block_on_focus_connect(d->zoom_entry);
gtk_box_pack_start(GTK_BOX(self->widget), d->zoom_entry, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT(d->zoom), "value-changed",
G_CALLBACK (_lib_lighttable_zoom_slider_changed),
(gpointer)self);
g_signal_connect(d->zoom_entry, "key-press-event", G_CALLBACK(_lib_lighttable_zoom_entry_changed), self);
gtk_range_set_value(GTK_RANGE(d->zoom), dt_conf_get_int("plugins/lighttable/images_in_row"));
darktable.view_manager->proxy.lighttable.module = self;
darktable.view_manager->proxy.lighttable.set_zoom = _lib_lighttable_set_zoom;
}
native_handle _chisel_native_slider_create( int type ) {
GtkWidget *widget;
if ( type == SliderTypeHorizontal ) {
widget = gtk_hscale_new_with_range( 0, 1, 0.001 );
} else {
widget = gtk_vscale_new_with_range( 0, 1, 0.001 );
}
gtk_scale_set_draw_value( GTK_SCALE(widget), FALSE );
g_signal_connect( G_OBJECT(widget), "value_changed", G_CALLBACK(_chisel_gtk_slider_changed_event), NULL );
return (native_handle)widget;
}
GtkWidget* CreateScale(const char* opt_name)
{
#if GTK_CHECK_VERSION(3, 0, 0)
GtkWidget* scale = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 0, 100, 10);
#else
GtkWidget* scale = gtk_hscale_new_with_range(0, 100, 10);
#endif
gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_RIGHT);
gtk_range_set_value(GTK_RANGE(scale), theApp.GetConfigI(opt_name));
g_signal_connect(scale, "value-changed", G_CALLBACK(CB_RangeChanged), const_cast<char*>(opt_name));
return scale;
}
GtkWidget *new_frame_hscale(const gchar *name,
GCallback callback, int size,
gpointer user_data)
{
GtkWidget *widget;
GtkWidget *frame;
frame = gtk_frame_new(name);
widget = gtk_hscale_new_with_range(0, size, 1);
g_signal_connect(G_OBJECT(widget), "value-changed", callback, user_data);
gtk_container_add(GTK_CONTAINER(frame), widget);
gtk_widget_show(widget);
gtk_widget_show(frame);
return (frame);
}
static void
create_testwidgets ()
{
GtkWidget *treeview;
GtkListStore *store;
GtkCellRenderer *renderer;
widgets[WIDGET_NULL] = NULL;
widgets[WIDGET_SCROLLBAR] = gtk_vscrollbar_new (NULL);
widgets[WIDGET_TOGGLE_BUTTON] = gtk_toggle_button_new_with_label ("blah");
widgets[WIDGET_STATUS_BAR] = gtk_statusbar_new ();
treeview = gtk_tree_view_new ();
/* set up the treeview */
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "Column1", renderer,
"text", 0, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "Column2", renderer,
"text", 0, NULL);
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (store));
widgets[WIDGET_TREE_VIEW] = treeview;
/* lets abuse the private API ... */
widgets[WIDGET_TREE_VIEW_HEADER] = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 0)->button;
widgets[WIDGET_SCALE] = gtk_hscale_new_with_range (0, 1, 0.1);
widgets[WIDGET_PROGRESS_BAR] = gtk_progress_bar_new ();
widgets[WIDGET_MENUBAR] = gtk_menu_bar_new ();
widgets[WIDGET_MENUBAR_ITEM] = gtk_menu_item_new_with_label ("blah");
gtk_menu_shell_append (GTK_MENU_SHELL (widgets[WIDGET_MENUBAR]), widgets[WIDGET_MENUBAR_ITEM]);
#ifndef GTK_DISABLE_DEPRECATED
widgets[WIDGET_OPTION_MENU] = gtk_option_menu_new ();
#else
#warning Not testing engines against GtkOptionMenu
#endif /* GTK_DISABLE_DEPRECATED */
widgets[WIDGET_TOOLBAR] = gtk_toolbar_new ();
widgets[WIDGET_DEFAULT_BUTTON] = gtk_button_new_with_label ("blah");
/* nasty but *shrug* */
GTK_WIDGET_SET_FLAGS(widgets[WIDGET_DEFAULT_BUTTON], GTK_CAN_DEFAULT);
GTK_WIDGET_SET_FLAGS(widgets[WIDGET_DEFAULT_BUTTON], GTK_HAS_DEFAULT);
}
GtkWidget *widget_hscale_create(
AttributeSet *Attr, tag_attr *attr, gint Type)
{
GtkWidget *widget;
gdouble range_min = 0;
gdouble range_max = 100;
gdouble range_step = 1;
gdouble range_value = 0;
gchar *value;
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Entering.\n", __func__);
#endif
/* Thunor: These "range-*" names are consistent with the spinbutton widget */
if (attr) {
if (!(value = get_tag_attribute(attr, "range-min")))
value = get_tag_attribute(attr, "scale-min");
if (value) range_min = atof(value);
if (!(value = get_tag_attribute(attr, "range-max")))
value = get_tag_attribute(attr, "scale-max");
if (value) range_max = atof(value);
if (!(value = get_tag_attribute(attr, "range-step")))
value = get_tag_attribute(attr, "scale-step");
if (value) range_step = atof(value);
if (!(value = get_tag_attribute(attr, "range-value")))
value = get_tag_attribute(attr, "scale-value");
if (value) range_value = atof(value);
}
if (Type == WIDGET_HSCALE) {
widget = gtk_hscale_new_with_range(range_min, range_max, range_step);
} else {
widget = gtk_vscale_new_with_range(range_min, range_max, range_step);
}
gtk_range_set_value(GTK_RANGE(widget), range_value);
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Exiting.\n", __func__);
#endif
return widget;
}
static GtkWidget *_xgamma_add_channel_widget (GtkWidget *pInteractiveWidget, gchar *cLabel, int iChannelNumber, guint *iSignalID, double fChannelGamma)
{
GtkWidget *pLabel = gtk_label_new (cLabel);
gtk_table_attach_defaults (GTK_TABLE (pInteractiveWidget), pLabel, 0, 1, iChannelNumber, iChannelNumber+1);
GtkWidget *pHScale = gtk_hscale_new_with_range (GAMMA_MIN, GAMMA_MAX, .02);
gtk_scale_set_digits (GTK_SCALE (pHScale), 2);
gtk_range_set_value (GTK_RANGE (pHScale), fChannelGamma);
gtk_widget_set (pHScale, "width-request", 150, NULL);
*iSignalID = g_signal_connect (G_OBJECT (pHScale),
"value-changed",
G_CALLBACK (on_scale_value_changed),
GINT_TO_POINTER (iChannelNumber));
gtk_table_attach_defaults (GTK_TABLE (pInteractiveWidget), pHScale, 1, 2, iChannelNumber, iChannelNumber+1);
return pHScale;
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE arg1, arg2, arg3;
GtkAdjustment *adj = NULL;
GtkWidget *widget;
rb_scan_args(argc, argv, "03", &arg1, &arg2, &arg3);
if (NIL_P(arg1) || RVAL2GTYPE(arg1) == GTK_TYPE_ADJUSTMENT){
if (!NIL_P(arg1)) adj = GTK_ADJUSTMENT(RVAL2GOBJ(arg1));
widget = gtk_hscale_new(adj);
} else {
widget = gtk_hscale_new_with_range(NUM2DBL(arg1),
NUM2DBL(arg2), NUM2DBL(arg3));
}
RBGTK_INITIALIZE(self, widget);
return Qnil;
}
ColorVisionDeficiencyConfig::ColorVisionDeficiencyConfig(ColorVisionDeficiency &transformation){
GtkWidget *table = gtk_table_new(2, 2, false);
GtkWidget *widget;
int table_y = 0;
table_y = 0;
gtk_table_attach(GTK_TABLE(table), gtk_label_aligned_new(_("Type:"), 0, 0.5, 0, 0), 0, 1, table_y, table_y + 1, GTK_FILL, GTK_FILL, 5, 5);
type = widget = create_type_list();
g_signal_connect(G_OBJECT(type), "changed", G_CALLBACK(ColorVisionDeficiencyConfig::type_combobox_change_cb), this);
gtk_table_attach(GTK_TABLE(table), widget, 1, 2, table_y, table_y + 1, GtkAttachOptions(GTK_FILL | GTK_EXPAND), GTK_FILL, 5, 0);
table_y++;
info_bar = widget = gtk_info_bar_new();
info_label = gtk_label_new("");
gtk_label_set_line_wrap(GTK_LABEL(info_label), true);
gtk_label_set_justify(GTK_LABEL(info_label), GTK_JUSTIFY_LEFT);
gtk_label_set_single_line_mode(GTK_LABEL(info_label), false);
gtk_misc_set_alignment(GTK_MISC(info_label), 0, 0.5);
gtk_widget_set_size_request(info_label, 1, -1);
GtkWidget *content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(info_bar));
gtk_container_add(GTK_CONTAINER(content_area), info_label);
gtk_widget_show_all(info_bar);
g_signal_connect(G_OBJECT(info_label), "size-allocate", G_CALLBACK(info_label_size_allocate_cb), this);
gtk_table_attach(GTK_TABLE(table), widget, 1, 2, table_y, table_y + 1, GtkAttachOptions(GTK_FILL | GTK_EXPAND), GTK_FILL, 5, 0);
table_y++;
gtk_combo_box_set_active(GTK_COMBO_BOX(type), transformation.type);
gtk_table_attach(GTK_TABLE(table), gtk_label_aligned_new(_("Strength:"), 0, 0.5, 0, 0), 0, 1, table_y, table_y + 1, GTK_FILL, GTK_FILL, 5, 5);
strength = widget = gtk_hscale_new_with_range(0, 100, 1);
gtk_range_set_value(GTK_RANGE(widget), transformation.strength * 100);
gtk_table_attach(GTK_TABLE(table), widget, 1, 2, table_y, table_y + 1, GtkAttachOptions(GTK_FILL | GTK_EXPAND), GTK_FILL, 5, 0);
table_y++;
main = table;
gtk_widget_show_all(main);
g_object_ref(main);
}
int task_backlight_setup(struct task *task, GtkWidget *box)
{
GtkWidget *hscale;
GtkAdjustment *adj;
int val;
val = get_backlight_value();
hscale = gtk_hscale_new_with_range(BACKLIGHT_MIN, BACKLIGHT_MAX, 1);
adj = gtk_range_get_adjustment((GtkRange *)hscale);
gtk_adjustment_set_value(adj, val);
g_signal_connect(G_OBJECT(adj), "value_changed",
G_CALLBACK(backlight_hscale_handler), NULL);
gtk_box_pack_start(GTK_BOX(box), hscale, TRUE, TRUE, 0);
gtk_widget_show(hscale);
return 0;
}
NedSpacementDialog::NedSpacementDialog(GtkWindow *parent, double spacement) : m_spacement(spacement) {
GtkWidget *dialog;
GtkWidget *spacement_frame;
dialog = gtk_dialog_new_with_buttons(_("Horizontal Spacement"), parent, (GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
g_signal_connect(dialog, "response", G_CALLBACK (OnClose), (void *) this);
spacement_frame = gtk_frame_new(_("Spacement"));
m_spacement_slider = gtk_hscale_new_with_range(MEASURE_MIN_SPREAD, MEASURE_MAX_SPREAD, MEASURE_SPREAD_STEP);
gtk_range_set_value(GTK_RANGE(m_spacement_slider), spacement);
gtk_container_add (GTK_CONTAINER(spacement_frame), m_spacement_slider);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), spacement_frame);
gtk_widget_show_all (dialog);
gtk_dialog_run(GTK_DIALOG(dialog));
}
/**
* @brief Build the GUI
*
* @return
*/
GtkWidget* buildVolumeUI() {
GtkWidget* label;
volumeFrame=gtk_frame_new("AF Gain");
gtk_widget_modify_bg(volumeFrame,GTK_STATE_NORMAL,&background);
gtk_widget_modify_fg(gtk_frame_get_label_widget(GTK_FRAME(volumeFrame)),GTK_STATE_NORMAL,&white);
volumeScale=gtk_hscale_new_with_range(0.0,100.0,10.0);
g_signal_connect(G_OBJECT(volumeScale),"value-changed",G_CALLBACK(volumeChanged),NULL);
gtk_range_set_value((GtkRange*)volumeScale,volume);
gtk_widget_set_size_request(GTK_WIDGET(volumeScale),150,25);
gtk_widget_show(volumeScale);
gtk_container_add(GTK_CONTAINER(volumeFrame),volumeScale);
gtk_widget_set_size_request(volumeFrame,200,55);
gtk_widget_show(volumeFrame);
SetRXOutputGain(0,0,volume/100.0);
return volumeFrame;
}
static void
test_slider_ranges (void)
{
GtkWidget *window = gtk_test_create_simple_window ("Test Window", "Test: gtk_test_warp_slider");
GtkWidget *hscale = gtk_hscale_new_with_range (-50, +50, 5);
gtk_container_add (GTK_CONTAINER (GTK_BIN (window)->child), hscale);
gtk_widget_show (hscale);
gtk_widget_show_now (window);
while (gtk_events_pending ())
gtk_main_iteration ();
gtk_test_slider_set_perc (hscale, 0.0);
while (gtk_events_pending ())
gtk_main_iteration ();
g_assert (gtk_test_slider_get_value (hscale) == -50);
gtk_test_slider_set_perc (hscale, 50.0);
while (gtk_events_pending ())
gtk_main_iteration ();
g_assert (fabs (gtk_test_slider_get_value (hscale)) < 0.0001);
gtk_test_slider_set_perc (hscale, 100.0);
while (gtk_events_pending ())
gtk_main_iteration ();
g_assert (gtk_test_slider_get_value (hscale) == +50.0);
}
static GtkWidget *wintrans_slider(GtkWidget *win) {
GtkWidget *hbox;
GtkWidget *label, *slider;
GtkWidget *frame;
int imalpha = purple_prefs_get_int(OPT_WINTRANS_IM_ALPHA);
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE);
gtk_widget_show(frame);
hbox = gtk_hbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(frame), hbox);
label = gtk_label_new(_("Opacity:"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
gtk_widget_show(hbox);
slider = gtk_hscale_new_with_range(50, 255, 1);
gtk_range_set_value(GTK_RANGE(slider), imalpha);
gtk_widget_set_usize(GTK_WIDGET(slider), 200, -1);
/* On slider val change, update window's transparency level */
g_signal_connect(GTK_OBJECT(slider), "value-changed",
G_CALLBACK(change_alpha), win);
gtk_box_pack_start(GTK_BOX(hbox), slider, FALSE, TRUE, 5);
/* Set the initial transparency level */
set_wintrans(win, imalpha, TRUE,
purple_prefs_get_bool(OPT_WINTRANS_IM_ONTOP));
gtk_widget_show_all(hbox);
return frame;
}
/*-----------------------------------------------------------------------------*//*!
InitFx()
Initializes the Fx.
*//*-----------------------------------------------------------------------------*/
Int32 CFxMToSMerger::InitFx(IFx **ppFxComponent)
{
Int32 hr = FX_ERROR;
/*! Create the Fx */
if(FEF_FAILED(hr = FEF_CreateFx(&(_pFx), g_strFxName)))
return hr;
*ppFxComponent = _pFx;
/*! Get the IFxState and publish the loading state */
hr = _pFx->FxGetInterface(IFX_STATE, (Void**)&_pFxState);
if(FEF_FAILED(hr))
return hr;
_pFxState->FxPublishState(_FxState = FX_LOADING_STATE);
/*! Get the IFxPinManager to create the Fx pins */
IFxPinManager* pFxPinManager = NULL;
hr = _pFx->FxGetInterface(IFX_PINMANGER, (Void**)&pFxPinManager);
if(FEF_FAILED(hr))
{
_pFxState->FxPublishState(_FxState = FX_ERROR_INIT_STATE);
return hr;
}
FX_PIN _FxPin[] =
{
{
"Mono/Stereo stream" //!< Pin Name
, PIN_IN //!< Pin Type
, &g_FxMediaType //!< Media Type
, 1 //!< Media Type number
, (IFxPinCallback*)this //!< Pin Callback
},
{
"Stereo stream" //!< Pin Name
, PIN_OUT //!< Pin Type
, &g_FxMediaType //!< Media Type
, 1 //!< Media Type number
, (IFxPinCallback*)this //!< Pin Callback
}
};
/*! Create the Fx pins */
hr = pFxPinManager->Create(&_FxPin[0], &_FxInputPinL._pInputPin);
if(FEF_FAILED(hr))
{
_pFxState->FxPublishState(_FxState = FX_ERROR_INIT_STATE);
return hr;
}
_FxInputPin.insert(make_pair(_FxInputPinL._pInputPin, &_FxInputPinL));
hr = pFxPinManager->Create(&_FxPin[0], &_FxInputPinR._pInputPin);
if(FEF_FAILED(hr))
{
_pFxState->FxPublishState(_FxState = FX_ERROR_INIT_STATE);
return hr;
}
_FxInputPin.insert(make_pair(_FxInputPinR._pInputPin, &_FxInputPinR));
hr = pFxPinManager->Create(&_FxPin[1], &_pFxOutputPin);
if(FEF_FAILED(hr))
{
_pFxState->FxPublishState(_FxState = FX_ERROR_INIT_STATE);
return hr;
}
/*! Get the IFxParam to create the Fx public parameters */
hr = _pFx->FxGetInterface(IFX_PARAM, (Void**)&_pFxParam);
if(FEF_FAILED(hr))
{
_pFxState->FxPublishState(_FxState = FX_ERROR_INIT_STATE);
return hr;
}
/*! Create the Fx public parameter */
Uint8 bDefault = 0;
Uint8 bDefaultMax = 1;
FX_PARAM FxParamSync = {"Synchronize", "On/Off", &bDefault, &bDefault, &bDefaultMax, UINT8_TYPE, 1};
hr = _pFxParam->AddFxParam(&FxParamSync);
if(FEF_FAILED(hr))
{
SAFE_RELEASE_INTERFACE(_pFxParam);
_pFxState->FxPublishState(_FxState = FX_ERROR_INIT_STATE);
return hr;
}
/* Create User interface */
_pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(_pWindow), "Merger property");
gtk_window_set_default_size(GTK_WINDOW(_pWindow), 320, 50);
gtk_container_set_border_width(GTK_CONTAINER(_pWindow), 4);
_pMainVBox = gtk_vbox_new(TRUE, 0);
gtk_container_add(GTK_CONTAINER(_pWindow), _pMainVBox);
_pFrame = gtk_frame_new("Synchronize input (On/Off)");
_pSlider = gtk_hscale_new_with_range((Float)bDefault, (Float)bDefaultMax, 1);
gtk_container_add(GTK_CONTAINER(_pFrame), _pSlider);
gtk_range_set_value(GTK_RANGE(_pSlider), bDefaultMax);
g_signal_connect(G_OBJECT(_pSlider), "value_changed", G_CALLBACK(CFxMToSMerger::SliderWrapper), this);
gtk_box_pack_start(GTK_BOX(_pMainVBox), _pFrame, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(_pWindow), "delete_event", G_CALLBACK(quit), _pWindow);
/*! We can release the PinManager */
SAFE_RELEASE_INTERFACE(pFxPinManager);
/*! Publish the init state to the observers */
_pFxState->FxPublishState(_FxState = FX_INIT_STATE);
return FX_OK;
}
static GtkWidget *get_config_frame(PurplePlugin *plugin) {
GtkWidget *ret;
GtkWidget *imtransbox, *bltransbox;
GtkWidget *hbox;
GtkWidget *label, *slider;
GtkWidget *button;
GtkWidget *trans_box;
ret = gtk_vbox_new(FALSE, 18);
gtk_container_set_border_width(GTK_CONTAINER (ret), 12);
/* IM Convo trans options */
imtransbox = pidgin_make_frame(ret, _("IM Conversation Windows"));
button = pidgin_prefs_checkbox(_("_IM window transparency"),
OPT_WINTRANS_IM_ENABLED, imtransbox);
g_signal_connect(GTK_OBJECT(button), "clicked",
G_CALLBACK(update_convs_wintrans),
(gpointer) OPT_WINTRANS_IM_ENABLED);
trans_box = gtk_vbox_new(FALSE, 18);
if (!purple_prefs_get_bool(OPT_WINTRANS_IM_ENABLED))
gtk_widget_set_sensitive(GTK_WIDGET(trans_box), FALSE);
gtk_widget_show(trans_box);
g_signal_connect(GTK_OBJECT(button), "clicked",
G_CALLBACK(pidgin_toggle_sensitive), trans_box);
button = pidgin_prefs_checkbox(_("_Show slider bar in IM window"),
OPT_WINTRANS_IM_SLIDER, trans_box);
g_signal_connect(GTK_OBJECT(button), "clicked",
G_CALLBACK(update_convs_wintrans),
(gpointer) OPT_WINTRANS_IM_SLIDER);
button = pidgin_prefs_checkbox(
_("Remove IM window transparency on focus"),
OPT_WINTRANS_IM_ONFOCUS, trans_box);
button = pidgin_prefs_checkbox(_("Always on top"), OPT_WINTRANS_IM_ONTOP,
trans_box);
g_signal_connect(GTK_OBJECT(button), "clicked",
G_CALLBACK(update_convs_wintrans),
(gpointer) OPT_WINTRANS_IM_ONTOP);
gtk_box_pack_start(GTK_BOX(imtransbox), trans_box, FALSE, FALSE, 5);
/* IM transparency slider */
hbox = gtk_hbox_new(FALSE, 5);
label = gtk_label_new(_("Opacity:"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
slider = gtk_hscale_new_with_range(50, 255, 1);
gtk_range_set_value(GTK_RANGE(slider),
purple_prefs_get_int(OPT_WINTRANS_IM_ALPHA));
gtk_widget_set_usize(GTK_WIDGET(slider), 200, -1);
g_signal_connect(GTK_OBJECT(slider), "value-changed",
G_CALLBACK(alpha_change), NULL);
g_signal_connect(GTK_OBJECT(slider), "focus-out-event",
G_CALLBACK(alpha_pref_set_int),
(gpointer) OPT_WINTRANS_IM_ALPHA);
gtk_box_pack_start(GTK_BOX(hbox), slider, FALSE, TRUE, 5);
gtk_widget_show_all(hbox);
gtk_box_pack_start(GTK_BOX(trans_box), hbox, FALSE, FALSE, 5);
/* Buddy List trans options */
bltransbox = pidgin_make_frame (ret, _("Buddy List Window"));
button = pidgin_prefs_checkbox(_("_Buddy List window transparency"),
OPT_WINTRANS_BL_ENABLED, bltransbox);
g_signal_connect(GTK_OBJECT(button), "clicked",
G_CALLBACK(set_blist_trans),
(gpointer) OPT_WINTRANS_BL_ENABLED);
trans_box = gtk_vbox_new(FALSE, 18);
if (!purple_prefs_get_bool(OPT_WINTRANS_BL_ENABLED))
gtk_widget_set_sensitive(GTK_WIDGET(trans_box), FALSE);
gtk_widget_show(trans_box);
g_signal_connect(GTK_OBJECT(button), "clicked",
G_CALLBACK(pidgin_toggle_sensitive), trans_box);
button = pidgin_prefs_checkbox(
_("Remove Buddy List window transparency on focus"),
OPT_WINTRANS_BL_ONFOCUS, trans_box);
button = pidgin_prefs_checkbox(_("Always on top"), OPT_WINTRANS_BL_ONTOP,
trans_box);
g_signal_connect(GTK_OBJECT(button), "clicked",
G_CALLBACK(set_blist_trans),
(gpointer) OPT_WINTRANS_BL_ONTOP);
gtk_box_pack_start(GTK_BOX(bltransbox), trans_box, FALSE, FALSE, 5);
/* IM transparency slider */
hbox = gtk_hbox_new(FALSE, 5);
label = gtk_label_new(_("Opacity:"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
slider = gtk_hscale_new_with_range(50, 255, 1);
gtk_range_set_value(GTK_RANGE(slider),
purple_prefs_get_int(OPT_WINTRANS_BL_ALPHA));
gtk_widget_set_usize(GTK_WIDGET(slider), 200, -1);
g_signal_connect(GTK_OBJECT(slider), "value-changed",
G_CALLBACK(bl_alpha_change), NULL);
g_signal_connect(GTK_OBJECT(slider), "focus-out-event",
G_CALLBACK(alpha_pref_set_int),
(gpointer) OPT_WINTRANS_BL_ALPHA);
gtk_box_pack_start(GTK_BOX(hbox), slider, FALSE, TRUE, 5);
gtk_widget_show_all(hbox);
gtk_box_pack_start(GTK_BOX(trans_box), hbox, FALSE, FALSE, 5);
gtk_widget_show_all(ret);
return ret;
}
static sequence_view_t *new_sequence_view( void *vp, int num )
{
sequence_view_t *seqv = (sequence_view_t*) vj_calloc(sizeof(sequence_view_t));
seqv->num = num;
seqv->backlink = vp;
seqv->event_box = gtk_event_box_new();
gtk_event_box_set_visible_window( GTK_EVENT_BOX(seqv->event_box), TRUE );
GTK_WIDGET_SET_FLAGS( seqv->event_box, GTK_CAN_FOCUS );
g_signal_connect( G_OBJECT( seqv->event_box ),
"button_press_event",
G_CALLBACK( seqv_mouse_press_event ),
(gpointer*) seqv );
gtk_widget_show( GTK_WIDGET( seqv->event_box ) );
gchar *track_title = g_new0( gchar, 20 );
sprintf(track_title, "Track %d", num );
seqv->frame = gtk_frame_new( track_title );
g_free(track_title);
gtk_container_set_border_width( GTK_CONTAINER( seqv->frame) , 1 );
gtk_widget_show( GTK_WIDGET( seqv->frame ) );
gtk_container_add( GTK_CONTAINER( seqv->event_box), seqv->frame );
seqv->main_vbox = gtk_vbox_new(FALSE,0);
gtk_container_add( GTK_CONTAINER( seqv->frame ), seqv->main_vbox );
gtk_widget_show( GTK_WIDGET( seqv->main_vbox ) );
seqv->area = gtk_image_new();
gtk_box_pack_start( GTK_BOX(seqv->main_vbox),GTK_WIDGET( seqv->area), FALSE,FALSE,0);
gtk_widget_set_size_request_( seqv->area, 176,144 ); //FIXME
seqv->panel = gtk_frame_new(NULL);
seqv->toggle = gtk_toggle_button_new_with_label( "preview" );
if(num>0) {
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(seqv->toggle), FALSE );
g_signal_connect( G_OBJECT( seqv->toggle ), "toggled", G_CALLBACK(sequence_preview_cb),
(gpointer)seqv );
gtk_box_pack_start( GTK_BOX(seqv->main_vbox), seqv->toggle,FALSE,FALSE, 0 );
gtk_widget_set_sensitive_( GTK_WIDGET( seqv->toggle ), FALSE );
gtk_widget_show( seqv->toggle );
} else {
gtk_box_pack_start( GTK_BOX(seqv->main_vbox), seqv->toggle,FALSE,FALSE, 0 );
gtk_widget_show( seqv->toggle );
gtk_widget_set_sensitive_( GTK_WIDGET( seqv->toggle ), FALSE );
}
GtkWidget *vvbox = gtk_vbox_new(FALSE, 0);
seqv->button_box = gtk_hbox_new(FALSE,0);
gtk_box_pack_start( GTK_BOX(vvbox), seqv->button_box ,FALSE,FALSE, 0 );
add_buttons( seqv,seqv,seqv->button_box );
gtk_widget_show( seqv->button_box );
gtk_container_add( GTK_CONTAINER( seqv->main_vbox ), seqv->panel );
seqv->button_box2 = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start( GTK_BOX(vvbox), seqv->button_box2, FALSE,FALSE, 0 );
add_buttons2( seqv,seqv,seqv->button_box2 );
gtk_widget_show( seqv->button_box2 );
gtk_container_add( GTK_CONTAINER( seqv->panel ), vvbox );
gtk_widget_show(vvbox);
GtkWidget *box = gtk_vbox_new(FALSE,0);
seqv->timeline_ = gtk_hscale_new_with_range( 0.0,1.0,0.1 );
gtk_scale_set_draw_value( GTK_SCALE(seqv->timeline_), FALSE );
//gtk_widget_set_size_request_( seqv->panel,180 ,180);
gtk_adjustment_set_value(
GTK_ADJUSTMENT(GTK_RANGE(seqv->timeline_)->adjustment), 0.0 );
gtk_widget_show( seqv->panel );
gtk_box_pack_start( GTK_BOX( box ), seqv->timeline_, FALSE,FALSE, 0 );
gtk_box_pack_start( GTK_BOX( vvbox ), box , FALSE,FALSE,0);
gtk_widget_show(seqv->timeline_);
g_signal_connect( seqv->timeline_, "value_changed",
(GCallback) sequence_set_current_frame, (gpointer*) seqv );
GtkWidget *scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_ETCHED_IN );
gtk_widget_set_size_request_(scroll,30,70);
gtk_container_set_border_width(GTK_CONTAINER(scroll),0);
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
GtkWidget *vvvbox = gtk_hbox_new(FALSE,0);
seqv->tracks = create_track_view(seqv->num, MAX_TRACKS, (void*) seqv );
gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( get_track_tree(seqv->tracks)) , FALSE );
gtk_widget_set_size_request_( get_track_tree(seqv->tracks),20,80 );
gtk_widget_show(scroll);
gtk_scrolled_window_add_with_viewport(
GTK_SCROLLED_WINDOW( scroll ), get_track_tree(seqv->tracks) );
gtk_widget_show( get_track_tree(seqv->tracks));
gtk_box_pack_start( GTK_BOX(vvvbox), scroll, TRUE,TRUE, 0);
GtkWidget *hhbox = gtk_hbox_new(FALSE,0);
seqv->sliders_[0] = gtk_vscale_new_with_range( -12.0,12.0,1.0 );
seqv->sliders_[1] = gtk_vscale_new_with_range( 0.0, 1.0, 0.01 );
gtk_adjustment_set_value(
GTK_ADJUSTMENT(GTK_RANGE(seqv->sliders_[0])->adjustment), 1.0 );
gtk_adjustment_set_value(
GTK_ADJUSTMENT(GTK_RANGE(seqv->sliders_[1])->adjustment), 0.0 );
gtk_scale_set_digits( GTK_SCALE(seqv->sliders_[1]), 2 );
g_signal_connect( G_OBJECT( seqv->sliders_[0] ), "value_changed", G_CALLBACK( seq_speed ),
(gpointer*)seqv );
g_signal_connect( G_OBJECT( seqv->sliders_[1] ), "value_changed", G_CALLBACK( seq_opacity ),
(gpointer*)seqv );
gtk_box_pack_start( GTK_BOX( hhbox ), seqv->sliders_[0], TRUE, TRUE, 0 );
gtk_box_pack_start( GTK_BOX( hhbox ), seqv->sliders_[1], TRUE, TRUE, 0 );
gtk_widget_show( seqv->sliders_[0] );
gtk_widget_show( seqv->sliders_[1] );
gtk_box_pack_start( GTK_BOX(vvvbox), hhbox, TRUE,TRUE, 0 );
gtk_widget_show( hhbox );
gtk_container_add( GTK_CONTAINER( box ), vvvbox );
gtk_widget_show( vvvbox );
gtk_widget_show( box );
GtkWidget *hbox = gtk_hbox_new(FALSE,0);
gtk_box_set_spacing( GTK_BOX(hbox), 10 );
seqv->labels_[0] = gtk_label_new( "00:00:00:00" );
seqv->labels_[1] = gtk_label_new( "00:00:00:00" );
gtk_box_pack_start( GTK_BOX( hbox ), seqv->labels_[0], FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX( hbox ), seqv->labels_[1], FALSE, FALSE, 0 );
gtk_widget_show( seqv->labels_[0] );
gtk_widget_show( seqv->labels_[1] );
gtk_box_pack_start( GTK_BOX(seqv->main_vbox), hbox, FALSE,FALSE, 0 );
gtk_widget_show( hbox );
gtk_widget_set_sensitive_(GTK_WIDGET(seqv->panel), FALSE );
gtk_widget_show( GTK_WIDGET( seqv->area ) );
return seqv;
}
//____________________________________________________
SliderDemoWidget::SliderDemoWidget( void )
{
// main widget
GtkWidget* mainWidget( gtk_hbox_new( false, 0 ) );
gtk_box_set_spacing( GTK_BOX( mainWidget ), 5 );
setWidget( mainWidget );
// setup
setName( "Sliders" );
setComments( "Shows the appearance of sliders, progress bars and scrollbars" );
setIconName( "measure" );
realize();
// horizontal sliders
{
// frame
GtkWidget* frame( gtk_frame_new( "Horizontal" ) );
gtk_box_pack_start( GTK_BOX( mainWidget ), frame, true, true, 0 );
gtk_widget_show( frame );
// container
GtkWidget* box( gtk_vbox_new( false, 0 ) );
gtk_container_set_border_width( GTK_CONTAINER( box ), 5 );
gtk_box_set_spacing( GTK_BOX( box ), 2 );
gtk_widget_show( box );
gtk_container_add( GTK_CONTAINER( frame ), box );
// scale
_horizontalSliders._scale = gtk_hscale_new_with_range( 0, 100, 1 );
gtk_scale_set_draw_value( GTK_SCALE( _horizontalSliders._scale ), false );
gtk_box_pack_start( GTK_BOX( box ), _horizontalSliders._scale, false, true, 0 );
gtk_widget_show( _horizontalSliders._scale );
// progress entry
_horizontalSliders._progressEntry = gtk_entry_new();
gtk_entry_set_text( GTK_ENTRY( _horizontalSliders._progressEntry ), "Progress Bar Entry" );
gtk_entry_set_progress_fraction( GTK_ENTRY( _horizontalSliders._progressEntry ), 0.25 );
gtk_box_pack_start( GTK_BOX( box ), _horizontalSliders._progressEntry, false, true, 0 );
gtk_widget_show( _horizontalSliders._progressEntry );
// progress bar
_horizontalSliders._progressBar = gtk_progress_bar_new();
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_orientable_set_orientation( GTK_ORIENTABLE( _horizontalSliders._progressBar ), GTK_ORIENTATION_HORIZONTAL );
#else
gtk_progress_bar_set_orientation( GTK_PROGRESS_BAR( _horizontalSliders._progressBar ), GTK_PROGRESS_LEFT_TO_RIGHT );
#endif
gtk_progress_set_show_text( GTK_PROGRESS( _horizontalSliders._progressBar ), true );
gtk_box_pack_start( GTK_BOX( box ), _horizontalSliders._progressBar, false, true, 0 );
gtk_widget_show( _horizontalSliders._progressBar );
// pulse progressBar
_pulseProgressBar = gtk_progress_bar_new();
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_orientable_set_orientation( GTK_ORIENTABLE( _pulseProgressBar ), GTK_ORIENTATION_HORIZONTAL );
#else
gtk_progress_bar_set_orientation( GTK_PROGRESS_BAR( _pulseProgressBar ), GTK_PROGRESS_LEFT_TO_RIGHT );
#endif
gtk_progress_bar_set_pulse_step( GTK_PROGRESS_BAR( _pulseProgressBar ), 0.01 );
gtk_box_pack_start( GTK_BOX( box ), _pulseProgressBar, false, true, 0 );
gtk_widget_show( _pulseProgressBar );
// scrollbar
GtkAdjustment* adjustment( GTK_ADJUSTMENT( gtk_adjustment_new( 25, 0, 110, 1, 1, 10 ) ) );
_horizontalSliders._scrollBar = gtk_hscrollbar_new( adjustment );
gtk_box_pack_start( GTK_BOX( box ), _horizontalSliders._scrollBar, false, true, 0 );
gtk_widget_show( _horizontalSliders._scrollBar );
}
// vertical sliders
{
// frame
GtkWidget* frame( gtk_frame_new( "Vertical" ) );
gtk_box_pack_start( GTK_BOX( mainWidget ), frame, false, true, 0 );
gtk_widget_show( frame );
// container
GtkWidget* box( gtk_hbox_new( false, 0 ) );
gtk_container_set_border_width( GTK_CONTAINER( box ), 5 );
gtk_box_set_spacing( GTK_BOX( box ), 5 );
gtk_widget_show( box );
gtk_container_add( GTK_CONTAINER( frame ), box );
// scale
_verticalSliders._scale = gtk_vscale_new_with_range( 0, 100, 1 );
gtk_scale_set_draw_value( GTK_SCALE( _verticalSliders._scale ), false );
gtk_box_pack_start( GTK_BOX( box ), _verticalSliders._scale, false, true, 0 );
gtk_widget_show( _verticalSliders._scale );
// progress bar
_verticalSliders._progressBar = gtk_progress_bar_new();
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_orientable_set_orientation( GTK_ORIENTABLE( _verticalSliders._progressBar ), GTK_ORIENTATION_VERTICAL );
#else
gtk_progress_bar_set_orientation( GTK_PROGRESS_BAR( _verticalSliders._progressBar ), GTK_PROGRESS_BOTTOM_TO_TOP );
#endif
gtk_progress_set_show_text( GTK_PROGRESS( _verticalSliders._progressBar ), true );
gtk_box_pack_start( GTK_BOX( box ), _verticalSliders._progressBar, false, true, 0 );
gtk_widget_show( _verticalSliders._progressBar );
// scrollbar
GtkAdjustment* adjustment( GTK_ADJUSTMENT( gtk_adjustment_new( 25, 0, 110, 1, 1, 10 ) ) );
_verticalSliders._scrollBar = gtk_vscrollbar_new( adjustment );
gtk_box_pack_start( GTK_BOX( box ), _verticalSliders._scrollBar, false, true, 0 );
gtk_widget_show( _verticalSliders._scrollBar );
}
// connections
connect( G_OBJECT( _horizontalSliders._scale ), "value-changed", GCallback( valueChanged ), this );
connect( G_OBJECT( _horizontalSliders._scrollBar ), "value-changed", GCallback( valueChanged ), this );
connect( G_OBJECT( _verticalSliders._scale ), "value-changed", GCallback( valueChanged ), this );
connect( G_OBJECT( _verticalSliders._scrollBar ), "value-changed", GCallback( valueChanged ), this );
// Initialize all
gtk_range_set_value( GTK_RANGE( _verticalSliders._scale ), 25 );
}
bool RunLinuxDialog()
{
GtkWidget *dialog;
GtkWidget *main_box, *central_box, *advance_box, *res_box, *hw_box, *sw_box, *shader_box;
GtkWidget *native_box, *fsaa_box, *resxy_box, *renderer_box, *interlace_box, *threads_box, *filter_box;
GtkWidget *hw_table, *shader_table, *res_frame, *hw_frame, *sw_frame, *shader_frame;
GtkWidget *interlace_combo_box, *threads_spin;
GtkWidget *interlace_label, *threads_label, *native_label, *fsaa_label, *rexy_label, *render_label, *filter_label;
GtkWidget *hack_table, *hack_skipdraw_label, *hack_box, *hack_frame;
GtkWidget *hack_alpha_check, *hack_date_check, *hack_offset_check, *hack_skipdraw_spin, *hack_msaa_check, *hack_sprite_check, * hack_wild_check, *hack_enble_check, *hack_logz_check;
GtkWidget *hack_tco_label, *hack_tco_entry;
GtkWidget *gl_box, *gl_frame, *gl_table;
GtkWidget *notebook, *page_label[2];
int return_value;
GdkPixbuf* logo_pixmap;
GtkWidget *logo_image;
/* Create the widgets */
dialog = gtk_dialog_new_with_buttons (
"GSdx Config",
NULL, /* parent window*/
(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
NULL);
// The main area for the whole dialog box.
main_box = gtk_vbox_new(false, 5);
central_box = gtk_vbox_new(false, 5);
advance_box = gtk_vbox_new(false, 5);
// The Internal resolution frame and container.
res_box = gtk_vbox_new(false, 5);
res_frame = gtk_frame_new ("OpenGL Internal Resolution (can cause glitches)");
gtk_container_add(GTK_CONTAINER(res_frame), res_box);
// The extra shader setting frame/container/table
shader_box = gtk_vbox_new(false, 5);
shader_frame = gtk_frame_new("Custom Shader Settings");
gtk_container_add(GTK_CONTAINER(shader_frame), shader_box);
shader_table = gtk_table_new(5,2, false);
gtk_container_add(GTK_CONTAINER(shader_box), shader_table);
// The hardware mode frame, container, and table.
hw_box = gtk_vbox_new(false, 5);
hw_frame = gtk_frame_new ("Hardware Mode Settings");
gtk_container_add(GTK_CONTAINER(hw_frame), hw_box);
hw_table = gtk_table_new(5,2, false);
gtk_container_add(GTK_CONTAINER(hw_box), hw_table);
// The software mode frame and container. (It doesn't have enough in it for a table.)
sw_box = gtk_vbox_new(false, 5);
sw_frame = gtk_frame_new ("Software Mode Settings");
gtk_container_add(GTK_CONTAINER(sw_frame), sw_box);
// The hack frame and container.
hack_box = gtk_hbox_new(false, 5);
hack_frame = gtk_frame_new ("Hacks");
gtk_container_add(GTK_CONTAINER(hack_frame), hack_box);
hack_table = gtk_table_new(3,3, false);
gtk_container_add(GTK_CONTAINER(hack_box), hack_table);
// Grab a logo, to make things look nice.
logo_pixmap = gdk_pixbuf_from_pixdata(&gsdx_ogl_logo, false, NULL);
logo_image = gtk_image_new_from_pixbuf(logo_pixmap);
gtk_box_pack_start(GTK_BOX(main_box), logo_image, true, true, 0);
// Create the renderer combo box and label, and stash them in a box.
render_label = gtk_label_new ("Renderer:");
render_combo_box = CreateRenderComboBox();
renderer_box = gtk_hbox_new(false, 5);
// Use gtk_box_pack_start instead of gtk_container_add so it lines up nicely.
gtk_box_pack_start(GTK_BOX(renderer_box), render_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(renderer_box), render_combo_box, false, false, 5);
// Create the interlace combo box and label, and stash them in a box.
interlace_label = gtk_label_new ("Interlacing (F5):");
interlace_combo_box = CreateInterlaceComboBox();
interlace_box = gtk_hbox_new(false, 5);
gtk_box_pack_start(GTK_BOX(interlace_box), interlace_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(interlace_box), interlace_combo_box, false, false, 5);
// Create the filter combo box.
filter_label = gtk_label_new ("Texture Filtering:");
filter_combo_box = CreateFilterComboBox();
filter_box = gtk_hbox_new(false, 5);
gtk_box_pack_start(GTK_BOX(filter_box), filter_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(filter_box), filter_combo_box, false, false, 0);
// Create the threading spin box and label, and stash them in a box. (Yes, we do a lot of that.)
threads_label = gtk_label_new("Extra rendering threads:");
threads_spin = gtk_spin_button_new_with_range(0,100,1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(threads_spin), theApp.GetConfig("extrathreads", 0));
threads_box = gtk_hbox_new(false, 0);
gtk_box_pack_start(GTK_BOX(threads_box), threads_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(threads_box), threads_spin, false, false, 5);
// A bit of funkiness for the resolution box.
native_label = gtk_label_new("Original PS2 Resolution: ");
native_res_check = gtk_check_button_new_with_label("Native");
native_box = gtk_hbox_new(false, 5);
gtk_box_pack_start(GTK_BOX(native_box), native_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(native_box), native_res_check, false, false, 5);
fsaa_label = gtk_label_new("Or Use Scaling:");
fsaa_combo_box = CreateMsaaComboBox();
fsaa_box = gtk_hbox_new(false, 5);
gtk_box_pack_start(GTK_BOX(fsaa_box), fsaa_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(fsaa_box), fsaa_combo_box, false, false, 5);
rexy_label = gtk_label_new("Custom Resolution:");
resx_spin = gtk_spin_button_new_with_range(256,8192,1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(resx_spin), theApp.GetConfig("resx", 1024));
resy_spin = gtk_spin_button_new_with_range(256,8192,1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(resy_spin), theApp.GetConfig("resy", 1024));
resxy_box = gtk_hbox_new(false, 5);
gtk_box_pack_start(GTK_BOX(resxy_box), rexy_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(resxy_box), resx_spin, false, false, 5);
gtk_box_pack_start(GTK_BOX(resxy_box), resy_spin, false, false, 5);
// Create our hack settings.
hack_alpha_check = gtk_check_button_new_with_label("Alpha Hack");
hack_date_check = gtk_check_button_new_with_label("Date Hack");
hack_offset_check = gtk_check_button_new_with_label("Offset Hack");
hack_skipdraw_label = gtk_label_new("Skipdraw:");
hack_skipdraw_spin = gtk_spin_button_new_with_range(0,1000,1);
hack_enble_check = gtk_check_button_new_with_label("Enable User Hacks");
hack_wild_check = gtk_check_button_new_with_label("Wild arm Hack");
hack_sprite_check = gtk_check_button_new_with_label("Sprite Hack");
hack_msaa_check = gtk_check_button_new_with_label("Msaa Hack");
hack_tco_label = gtk_label_new("Texture Offset: 0x");
hack_tco_entry = gtk_entry_new();
hack_logz_check = gtk_check_button_new_with_label("Log Depth Hack");
gtk_spin_button_set_value(GTK_SPIN_BUTTON(hack_skipdraw_spin), theApp.GetConfig("UserHacks_SkipDraw", 0));
set_hex_entry(hack_tco_entry, theApp.GetConfig("UserHacks_TCOffset", 0));
// Tables are strange. The numbers are for their position: left, right, top, bottom.
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_alpha_check, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_offset_check, 1, 2, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_sprite_check, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_wild_check, 1, 2, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_logz_check, 0, 1, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_date_check, 1, 2, 2, 3);
// Note: MSAA is not implemented yet. I disable it to make the table square
//gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_msaa_check, 2, 3, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_skipdraw_label, 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_skipdraw_spin, 1, 2, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_tco_label, 0, 1, 4, 5);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_tco_entry, 1, 2, 4, 5);
// Create our checkboxes.
shadeboost_check = gtk_check_button_new_with_label("Shade boost");
paltex_check = gtk_check_button_new_with_label("Allow 8 bits textures");
fba_check = gtk_check_button_new_with_label("Alpha correction (FBA)");
aa_check = gtk_check_button_new_with_label("Edge anti-aliasing (AA1)");
fxaa_check = gtk_check_button_new_with_label("Fxaa shader");
// Set the checkboxes.
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(shadeboost_check), theApp.GetConfig("shadeboost", 1));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(paltex_check), theApp.GetConfig("paltex", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fba_check), theApp.GetConfig("fba", 1));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(aa_check), theApp.GetConfig("aa1", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fxaa_check), theApp.GetConfig("fxaa", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(native_res_check), theApp.GetConfig("nativeres", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_alpha_check), theApp.GetConfig("UserHacks_AlphaHack", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_offset_check), theApp.GetConfig("UserHacks_HalfPixelOffset", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_date_check), theApp.GetConfig("UserHacks_DateGL4", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_enble_check), theApp.GetConfig("UserHacks", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_msaa_check), theApp.GetConfig("UserHacks_MSAA", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_wild_check), theApp.GetConfig("UserHacks_WildHack", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_sprite_check), theApp.GetConfig("UserHacks_SpriteHack", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_logz_check), theApp.GetConfig("logz", 1));
// Shadeboost scale
sb_brightness = gtk_hscale_new_with_range(0, 200, 10);
GtkWidget* sb_brightness_label = gtk_label_new("Shade Boost Brightness");
gtk_scale_set_value_pos(GTK_SCALE(sb_brightness), GTK_POS_RIGHT);
gtk_range_set_value(GTK_RANGE(sb_brightness), theApp.GetConfig("ShadeBoost_Brightness", 50));
sb_contrast = gtk_hscale_new_with_range(0, 200, 10);
GtkWidget* sb_contrast_label = gtk_label_new("Shade Boost Contrast");
gtk_scale_set_value_pos(GTK_SCALE(sb_contrast), GTK_POS_RIGHT);
gtk_range_set_value(GTK_RANGE(sb_contrast), theApp.GetConfig("ShadeBoost_Contrast", 50));
sb_saturation = gtk_hscale_new_with_range(0, 200, 10);
GtkWidget* sb_saturation_label = gtk_label_new("Shade Boost Saturation");
gtk_scale_set_value_pos(GTK_SCALE(sb_saturation), GTK_POS_RIGHT);
gtk_range_set_value(GTK_RANGE(sb_saturation), theApp.GetConfig("ShadeBoost_Saturation", 50));
// Populate all those boxes we created earlier with widgets.
gtk_container_add(GTK_CONTAINER(res_box), native_box);
gtk_container_add(GTK_CONTAINER(res_box), fsaa_box);
gtk_container_add(GTK_CONTAINER(res_box), resxy_box);
gtk_container_add(GTK_CONTAINER(sw_box), threads_box);
gtk_container_add(GTK_CONTAINER(sw_box), aa_check);
// Tables are strange. The numbers are for their position: left, right, top, bottom.
gtk_table_attach_defaults(GTK_TABLE(shader_table), fxaa_check, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(shader_table), shadeboost_check, 1, 2, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_brightness_label, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_brightness, 1, 2, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_contrast_label, 0, 1, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_contrast, 1, 2, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_saturation_label, 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_saturation, 1, 2, 3, 4);
// Tables are strange. The numbers are for their position: left, right, top, bottom.
gtk_table_attach_defaults(GTK_TABLE(hw_table), filter_box, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(hw_table), paltex_check, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(hw_table), fba_check, 1, 2, 1, 2);
// The GL advance options
gl_box = gtk_vbox_new(false, 5);
gl_frame = gtk_frame_new ("OpenGL Very Advanced Custom Settings");
gtk_container_add(GTK_CONTAINER(gl_frame), gl_box);
gl_table = gtk_table_new(10, 2, false);
gtk_container_add(GTK_CONTAINER(gl_box), gl_table);
GtkWidget* gl_bs_label = gtk_label_new("Buffer Storage:");
GtkWidget* gl_bs_combo = CreateGlComboBox("override_GL_ARB_buffer_storage");
GtkWidget* gl_bt_label = gtk_label_new("Bindless Texture:");
GtkWidget* gl_bt_combo = CreateGlComboBox("override_GL_ARB_bindless_texture");
GtkWidget* gl_sso_label = gtk_label_new("Separate Shader:");
GtkWidget* gl_sso_combo = CreateGlComboBox("override_GL_ARB_separate_shader_objects");
GtkWidget* gl_ss_label = gtk_label_new("Shader Subroutine:");
GtkWidget* gl_ss_combo = CreateGlComboBox("override_GL_ARB_shader_subroutine");
GtkWidget* gl_gs_label = gtk_label_new("Geometry Shader:");
GtkWidget* gl_gs_combo = CreateGlComboBox("override_geometry_shader");
GtkWidget* gl_ils_label = gtk_label_new("Image Load Store:");
GtkWidget* gl_ils_combo = CreateGlComboBox("override_GL_ARB_shader_image_load_store");
GtkWidget* gl_cc_label = gtk_label_new("Clip Control (depth accuracy):");
GtkWidget* gl_cc_combo = CreateGlComboBox("override_GL_ARB_clip_control");
GtkWidget* gl_ct_label = gtk_label_new("Clear Texture:");
GtkWidget* gl_ct_combo = CreateGlComboBox("override_GL_ARB_clear_texture");
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_gs_label, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_gs_combo, 1, 2, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_bs_label, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_bs_combo, 1, 2, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_bt_label, 0, 1, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_bt_combo, 1, 2, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_sso_label, 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_sso_combo, 1, 2, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ss_label, 0, 1, 4, 5);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ss_combo, 1, 2, 4, 5);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ils_label, 0, 1, 5, 6);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ils_combo, 1, 2, 5, 6);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_cc_label, 0, 1, 6, 7);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_cc_combo, 1, 2, 6, 7);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ct_label, 0, 1, 7, 8);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ct_combo, 1, 2, 7, 8);
// those one are properly detected so no need a gui
#if 0
override_GL_ARB_copy_image = -1
override_GL_ARB_explicit_uniform_location = -1
override_GL_ARB_gpu_shader5 = -1
override_GL_ARB_shading_language_420pack = -1
#endif
// Handle some nice tab
notebook = gtk_notebook_new();
page_label[0] = gtk_label_new("Global Setting");
page_label[1] = gtk_label_new("Advance Setting");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), central_box, page_label[0]);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), advance_box, page_label[1]);
// Put everything in the big box.
gtk_container_add(GTK_CONTAINER(main_box), renderer_box);
gtk_container_add(GTK_CONTAINER(main_box), interlace_box);
gtk_container_add(GTK_CONTAINER(main_box), notebook);
gtk_container_add(GTK_CONTAINER(central_box), res_frame);
gtk_container_add(GTK_CONTAINER(central_box), shader_frame);
gtk_container_add(GTK_CONTAINER(central_box), hw_frame);
gtk_container_add(GTK_CONTAINER(central_box), sw_frame);
gtk_container_add(GTK_CONTAINER(advance_box), hack_frame);
gtk_container_add(GTK_CONTAINER(advance_box), gl_frame);
// Put the box in the dialog and show it to the world.
gtk_container_add (GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), main_box);
gtk_widget_show_all (dialog);
return_value = gtk_dialog_run (GTK_DIALOG (dialog));
if (return_value == GTK_RESPONSE_ACCEPT)
{
int mode_height = 0, mode_width = 0;
mode_width = theApp.GetConfig("ModeWidth", 640);
mode_height = theApp.GetConfig("ModeHeight", 480);
theApp.SetConfig("ModeHeight", mode_height);
theApp.SetConfig("ModeWidth", mode_width);
// Get all the settings from the dialog box.
if (gtk_combo_box_get_active(GTK_COMBO_BOX(render_combo_box)) != -1) {
// Note the value are based on m_gs_renderers vector on GSdx.cpp
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(render_combo_box))) {
case 2: theApp.SetConfig("renderer", 10); break;
case 3: theApp.SetConfig("renderer", 11); break;
case 4: theApp.SetConfig("renderer", 12); break;
case 5: theApp.SetConfig("renderer", 13); break;
// Fallback to SW opengl
default: theApp.SetConfig("renderer", 13); break;
}
}
if (gtk_combo_box_get_active(GTK_COMBO_BOX(interlace_combo_box)) != -1)
theApp.SetConfig( "interlace", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(interlace_combo_box)));
theApp.SetConfig("extrathreads", (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(threads_spin)));
theApp.SetConfig("filter", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(filter_combo_box)));
theApp.SetConfig("shadeboost", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(shadeboost_check)));
theApp.SetConfig("paltex", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(paltex_check)));
theApp.SetConfig("fba", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fba_check)));
theApp.SetConfig("aa1", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(aa_check)));
theApp.SetConfig("fxaa", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fxaa_check)));
theApp.SetConfig("nativeres", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(native_res_check)));
theApp.SetConfig("ShadeBoost_Saturation", (int)gtk_range_get_value(GTK_RANGE(sb_saturation)));
theApp.SetConfig("ShadeBoost_Brightness", (int)gtk_range_get_value(GTK_RANGE(sb_brightness)));
theApp.SetConfig("ShadeBoost_Contrast", (int)gtk_range_get_value(GTK_RANGE(sb_contrast)));
theApp.SetConfig("upscale_multiplier", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(fsaa_combo_box))+1);
theApp.SetConfig("resx", (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(resx_spin)));
theApp.SetConfig("resy", (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(resy_spin)));
theApp.SetConfig("UserHacks_SkipDraw", (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(hack_skipdraw_spin)));
theApp.SetConfig("UserHacks_HalfPixelOffset", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_offset_check)));
theApp.SetConfig("UserHacks_AlphaHack", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_alpha_check)));
theApp.SetConfig("logz", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_logz_check)));
theApp.SetConfig("UserHacks_DateGL4", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_date_check)));
theApp.SetConfig("UserHacks_MSAA", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_msaa_check)));
theApp.SetConfig("UserHacks_WildHack", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_wild_check)));
theApp.SetConfig("UserHacks_SpriteHack", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_sprite_check)));
theApp.SetConfig("UserHacks", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_enble_check)));
theApp.SetConfig("UserHacks_TCOffset", get_hex_entry(hack_tco_entry));
theApp.SetConfig("override_GL_ARB_clear_texture", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_ct_combo)) - 1);
theApp.SetConfig("override_GL_ARB_bindless_texture", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_bt_combo)) - 1);
theApp.SetConfig("override_GL_ARB_buffer_storage", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_bs_combo)) - 1);
theApp.SetConfig("override_GL_ARB_separate_shader_objects", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_sso_combo)) - 1);
theApp.SetConfig("override_GL_ARB_shader_subroutine", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_ss_combo)) - 1);
theApp.SetConfig("override_geometry_shader", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_gs_combo)) - 1);
theApp.SetConfig("override_GL_ARB_shader_image_load_store", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_ils_combo)) - 1);
theApp.SetConfig("override_GL_ARB_clip_control", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_cc_combo)) - 1);
// NOT supported yet
theApp.SetConfig("msaa", 0);
// Let's just be windowed for the moment.
theApp.SetConfig("windowed", 1);
gtk_widget_destroy (dialog);
return true;
}
gtk_widget_destroy (dialog);
return false;
}
static GtkWidget *
create_selection_file(GjayApp *gjay, SelectUI *sui)
{
GtkWidget *frame, *label, *table, *vbox, *align, *top_hbox;
int i;
gchar *headings[] = {"Artist", "Title", "Freq", "BPM", "Color", 0};
frame = gtk_frame_new(_("Song Details"));
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_usize(frame, APP_WIDTH * 0.5, -1);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox);
top_hbox = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), top_hbox, FALSE, FALSE, 0);
sui->song_icon = gtk_image_new_from_pixbuf(
gjay_get_pixbuf(gjay, PM_ICON_CLOSED));
gtk_box_pack_start(GTK_BOX(top_hbox), sui->song_icon, FALSE, FALSE, 0);
sui->song_play = gjay_button_new_with_label_pixbuf(gjay, _("Play"),
PM_BUTTON_PLAY);
g_signal_connect(G_OBJECT(sui->song_play), "clicked",
G_CALLBACK(song_play_clicked), gjay);
gtk_box_pack_start(GTK_BOX(top_hbox), sui->song_play, FALSE, FALSE, 0);
table = gtk_table_new(6, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
for(i=0; headings[i]; i++) {
gchar *buf;
label = gtk_label_new(NULL);
buf = g_strdup_printf("<b>%s</b>", headings[i]);
gtk_label_set_markup(GTK_LABEL(label), buf);
g_free(buf);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, i, i+1,
GTK_FILL, GTK_FILL, 10, 5);
}
sui->song_artist = gtk_label_new(_("Unknown"));
align = gtk_alignment_new(0, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(align), sui->song_artist);
gtk_table_attach_defaults(GTK_TABLE(table),
align, 1, 2, 0, 1);
sui->song_title = gtk_label_new(_("Unknown"));
align = gtk_alignment_new(0, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(align), sui->song_title);
gtk_table_attach_defaults(GTK_TABLE(table),
align, 1, 2, 1, 2);
sui->song_freq = gtk_image_new_from_pixbuf(
gjay_get_pixbuf(gjay, PM_ICON_CLOSED));
align = gtk_alignment_new(0, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(align), sui->song_freq);
gtk_table_attach_defaults(GTK_TABLE(table),
align, 1, 2, 2, 3);
sui->song_bpm = gtk_label_new(_("Unknown"));
align = gtk_alignment_new(0, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(align), sui->song_bpm);
gtk_table_attach_defaults(GTK_TABLE(table),
align, 1, 2, 3, 4);
sui->song_color = gtk_color_button_new();
align = gtk_alignment_new(0, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(align), sui->song_color);
gtk_table_attach_defaults(GTK_TABLE(table),
align, 1, 2, 4, 5);
/* Rating is optional */
sui->rating_label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(sui->rating_label), "<b>Rating:</b>");
gtk_table_attach(GTK_TABLE(table), sui->rating_label, 0, 1, 5, 6,
GTK_FILL, GTK_FILL, 10, 5);
sui->song_rating = gtk_hscale_new_with_range(MIN_RATING,MAX_RATING, 0.2);
g_signal_connect (G_OBJECT(sui->song_rating), "value-changed",
G_CALLBACK (rating_changed), gjay);
align = gtk_alignment_new(0, 0.5, 1, 0);
gtk_container_add(GTK_CONTAINER(align), sui->song_rating);
gtk_table_attach_defaults(GTK_TABLE(table),
align, 1, 2, 5, 6);
return frame;
}
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 DisplayDialog()
{
int return_value;
GtkWidget *dialog;
GtkWidget *main_frame, *main_box;
GtkWidget *mixing_frame, *mixing_box;
GtkWidget *int_label, *int_box;
GtkWidget *effects_check;
GtkWidget *dealias_filter;
GtkWidget *debug_check;
GtkWidget *debug_button;
GtkWidget *output_frame, *output_box;
GtkWidget *mod_label, *mod_box;
GtkWidget *api_label, *api_box;
#if SDL_MAJOR_VERSION >= 2
GtkWidget *sdl_api_label, *sdl_api_box;
#endif
GtkWidget *latency_label, *latency_slide;
GtkWidget *sync_label, *sync_box;
GtkWidget *advanced_button;
/* Create the widgets */
dialog = gtk_dialog_new_with_buttons(
"SPU2-X Config",
NULL, /* parent window*/
(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
"OK", GTK_RESPONSE_ACCEPT,
"Cancel", GTK_RESPONSE_REJECT,
NULL);
int_label = gtk_label_new("Interpolation:");
int_box = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(int_box), "0 - Nearest (fastest/bad quality)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(int_box), "1 - Linear (simple/okay sound)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(int_box), "2 - Cubic (artificial highs)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(int_box), "3 - Hermite (better highs)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(int_box), "4 - Catmull-Rom (PS2-like/slow)");
gtk_combo_box_set_active(GTK_COMBO_BOX(int_box), Interpolation);
effects_check = gtk_check_button_new_with_label("Disable Effects Processing");
dealias_filter = gtk_check_button_new_with_label("Use the de-alias filter (overemphasizes the highs)");
debug_check = gtk_check_button_new_with_label("Enable Debug Options");
debug_button = gtk_button_new_with_label("Debug...");
mod_label = gtk_label_new("Module:");
mod_box = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(mod_box), "0 - No Sound (emulate SPU2 only)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(mod_box), "1 - PortAudio (cross-platform)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(mod_box), "2 - SDL Audio (recommended for PulseAudio)");
//gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(mod_box), "3 - Alsa (probably doesn't work)");
gtk_combo_box_set_active(GTK_COMBO_BOX(mod_box), OutputModule);
api_label = gtk_label_new("PortAudio API:");
api_box = gtk_combo_box_text_new();
#ifdef __linux__
// In order to keep it the menu light, I only put linux major api
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(api_box), "0 - ALSA (recommended)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(api_box), "1 - OSS (legacy)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(api_box), "2 - JACK");
#else
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(api_box), "OSS");
#endif
gtk_combo_box_set_active(GTK_COMBO_BOX(api_box), OutputAPI);
#if SDL_MAJOR_VERSION >= 2
sdl_api_label = gtk_label_new("SDL API:");
sdl_api_box = gtk_combo_box_text_new();
// YES It sucks ...
for (int i = 0; i < SDL_GetNumAudioDrivers(); ++i) {
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sdl_api_box), SDL_GetAudioDriver(i));
}
gtk_combo_box_set_active(GTK_COMBO_BOX(sdl_api_box), SdlOutputAPI);
#endif
latency_label = gtk_label_new("Latency:");
const int min_latency = SynchMode == 0 ? LATENCY_MIN_TIMESTRETCH : LATENCY_MIN;
#if GTK_MAJOR_VERSION < 3
latency_slide = gtk_hscale_new_with_range(min_latency, LATENCY_MAX, 5);
#else
latency_slide = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, min_latency, LATENCY_MAX, 5);
#endif
gtk_range_set_value(GTK_RANGE(latency_slide), SndOutLatencyMS);
sync_label = gtk_label_new("Synchronization Mode:");
sync_box = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sync_box), "TimeStretch (Recommended)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sync_box), "Async Mix (Breaks some games!)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sync_box), "None (Audio can skip.)");
gtk_combo_box_set_active(GTK_COMBO_BOX(sync_box), SynchMode);
advanced_button = gtk_button_new_with_label("Advanced...");
#if GTK_MAJOR_VERSION < 3
main_box = gtk_hbox_new(false, 5);
#else
main_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
#endif
main_frame = gtk_frame_new("SPU2-X Config");
gtk_container_add(GTK_CONTAINER(main_frame), main_box);
#if GTK_MAJOR_VERSION < 3
mixing_box = gtk_vbox_new(false, 5);
#else
mixing_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
#endif
mixing_frame = gtk_frame_new("Mixing Settings:");
gtk_container_add(GTK_CONTAINER(mixing_frame), mixing_box);
#if GTK_MAJOR_VERSION < 3
output_box = gtk_vbox_new(false, 5);
#else
output_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
#endif
output_frame = gtk_frame_new("Output Settings:");
gtk_container_add(GTK_CONTAINER(output_frame), output_box);
gtk_container_add(GTK_CONTAINER(mixing_box), int_label);
gtk_container_add(GTK_CONTAINER(mixing_box), int_box);
gtk_container_add(GTK_CONTAINER(mixing_box), effects_check);
gtk_container_add(GTK_CONTAINER(mixing_box), dealias_filter);
gtk_container_add(GTK_CONTAINER(mixing_box), debug_check);
gtk_container_add(GTK_CONTAINER(mixing_box), debug_button);
gtk_container_add(GTK_CONTAINER(output_box), mod_label);
gtk_container_add(GTK_CONTAINER(output_box), mod_box);
gtk_container_add(GTK_CONTAINER(output_box), api_label);
gtk_container_add(GTK_CONTAINER(output_box), api_box);
#if SDL_MAJOR_VERSION >= 2
gtk_container_add(GTK_CONTAINER(output_box), sdl_api_label);
gtk_container_add(GTK_CONTAINER(output_box), sdl_api_box);
#endif
gtk_container_add(GTK_CONTAINER(output_box), sync_label);
gtk_container_add(GTK_CONTAINER(output_box), sync_box);
gtk_container_add(GTK_CONTAINER(output_box), latency_label);
gtk_container_add(GTK_CONTAINER(output_box), latency_slide);
gtk_container_add(GTK_CONTAINER(output_box), advanced_button);
gtk_container_add(GTK_CONTAINER(main_box), mixing_frame);
gtk_container_add(GTK_CONTAINER(main_box), output_frame);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(effects_check), EffectsDisabled);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dealias_filter), postprocess_filter_dealias);
//FinalVolume;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(debug_check), DebugEnabled);
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), main_frame);
gtk_widget_show_all(dialog);
g_signal_connect(sync_box, "changed", G_CALLBACK(cb_adjust_latency), latency_slide);
g_signal_connect_swapped(advanced_button, "clicked", G_CALLBACK(advanced_dialog), advanced_button);
g_signal_connect_swapped(debug_button, "clicked", G_CALLBACK(debug_dialog), debug_button);
return_value = gtk_dialog_run(GTK_DIALOG(dialog));
if (return_value == GTK_RESPONSE_ACCEPT) {
DebugEnabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(debug_check));
postprocess_filter_dealias = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dealias_filter));
if (gtk_combo_box_get_active(GTK_COMBO_BOX(int_box)) != -1)
Interpolation = gtk_combo_box_get_active(GTK_COMBO_BOX(int_box));
EffectsDisabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(effects_check));
//FinalVolume;
if (gtk_combo_box_get_active(GTK_COMBO_BOX(mod_box)) != -1)
OutputModule = gtk_combo_box_get_active(GTK_COMBO_BOX(mod_box));
if (gtk_combo_box_get_active(GTK_COMBO_BOX(api_box)) != -1) {
OutputAPI = gtk_combo_box_get_active(GTK_COMBO_BOX(api_box));
#ifdef __linux__
switch (OutputAPI) {
case 0:
PortaudioOut->SetApiSettings(L"ALSA");
break;
case 1:
PortaudioOut->SetApiSettings(L"OSS");
break;
case 2:
PortaudioOut->SetApiSettings(L"JACK");
break;
default:
PortaudioOut->SetApiSettings(L"Unknown");
}
#else
switch (OutputAPI) {
case 0:
PortaudioOut->SetApiSettings(L"OSS");
break;
default:
PortaudioOut->SetApiSettings(L"Unknown");
}
#endif
}
#if SDL_MAJOR_VERSION >= 2
if (gtk_combo_box_get_active(GTK_COMBO_BOX(sdl_api_box)) != -1) {
SdlOutputAPI = gtk_combo_box_get_active(GTK_COMBO_BOX(sdl_api_box));
// YES It sucks ...
SDLOut->SetApiSettings(wxString(SDL_GetAudioDriver(SdlOutputAPI), wxConvUTF8));
}
#endif
SndOutLatencyMS = gtk_range_get_value(GTK_RANGE(latency_slide));
if (gtk_combo_box_get_active(GTK_COMBO_BOX(sync_box)) != -1)
SynchMode = gtk_combo_box_get_active(GTK_COMBO_BOX(sync_box));
}
gtk_widget_destroy(dialog);
}
/**
* rstto_preferences_dialog_init:
* @dialog: The PreferencesDialog, used for configuring ristretto
* properties.
*
*
* This function initializes the preferences-dialog.
*
*
* get_properties ()
*
* configure_display_tab
*
* background_color_frame
*
* quality_frame
*
* configure_fullscreen_tab
*
* clock_frame
*
* thumbnails_frame
*
* configure_slideshow_tab
*
* slideshow_timeout_frame
*
* configure_control_tab
*
* scrollwheel_frame
*
* configure_behaviour_tab
*
* startup_frame
*
* desktop_frame
*/
static void
rstto_preferences_dialog_init ( RsttoPreferencesDialog *dialog )
{
/* Variable Section */
gboolean bool_invert_zoom_direction;
gboolean bool_bgcolor_override;
guint uint_slideshow_timeout;
gboolean bool_hide_thumbnails_fullscreen;
gboolean bool_wrap_images;
gboolean bool_maximize_on_startup;
gboolean bool_show_clock;
gboolean bool_limit_quality;
gchar *str_desktop_type = NULL;
GdkColor *bgcolor;
GtkWidget *timeout_lbl, *timeout_hscale;
GtkWidget *display_main_vbox;
GtkWidget *display_main_lbl;
GtkWidget *fullscreen_main_vbox;
GtkWidget *fullscreen_main_lbl;
GtkWidget *slideshow_main_vbox;
GtkWidget *slideshow_main_lbl;
GtkWidget *control_main_vbox;
GtkWidget *control_main_lbl;
GtkWidget *behaviour_main_vbox;
GtkWidget *behaviour_main_lbl;
GtkWidget *behaviour_desktop_lbl;
GtkWidget *notebook = gtk_notebook_new ();
/* Code Section */
dialog->priv = g_new0 (RsttoPreferencesDialogPriv, 1);
dialog->priv->settings = rstto_settings_new ();
/*
* Get all properties from the ristretto settings container
*/
g_object_get (
G_OBJECT (dialog->priv->settings),
"invert-zoom-direction", &bool_invert_zoom_direction,
"bgcolor-override", &bool_bgcolor_override,
"bgcolor", &bgcolor,
"slideshow-timeout", &uint_slideshow_timeout,
"hide-thumbnails-fullscreen", &bool_hide_thumbnails_fullscreen,
"maximize-on-startup", &bool_maximize_on_startup,
"wrap-images", &bool_wrap_images,
"desktop-type", &str_desktop_type,
"show-clock", &bool_show_clock,
"limit-quality", &bool_limit_quality,
NULL);
/*
* Configure the display tab
*/
display_main_vbox = gtk_vbox_new(FALSE, 0);
display_main_lbl = gtk_label_new(_("Display"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), display_main_vbox, display_main_lbl);
/**
* Bg-color frame
*/
dialog->priv->display_tab.bgcolor_vbox = gtk_vbox_new (FALSE, 0);
dialog->priv->display_tab.bgcolor_frame = xfce_gtk_frame_box_new_with_content(_("Background color"),
dialog->priv->display_tab.bgcolor_vbox);
gtk_box_pack_start (GTK_BOX (display_main_vbox), dialog->priv->display_tab.bgcolor_frame, FALSE, FALSE, 0);
dialog->priv->display_tab.bgcolor_override_check_button = gtk_check_button_new_with_label (_("Override background color:"));
dialog->priv->display_tab.bgcolor_hbox = gtk_hbox_new (FALSE, 4);
dialog->priv->display_tab.bgcolor_color_button = gtk_color_button_new();
gtk_box_pack_start (GTK_BOX (dialog->priv->display_tab.bgcolor_hbox),
dialog->priv->display_tab.bgcolor_override_check_button, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (dialog->priv->display_tab.bgcolor_hbox),
dialog->priv->display_tab.bgcolor_color_button, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (dialog->priv->display_tab.bgcolor_vbox),
dialog->priv->display_tab.bgcolor_hbox, FALSE, FALSE, 0);
/* set current value */
gtk_color_button_set_color (GTK_COLOR_BUTTON (dialog->priv->display_tab.bgcolor_color_button),
bgcolor);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->display_tab.bgcolor_override_check_button),
bool_bgcolor_override);
gtk_widget_set_sensitive (GTK_WIDGET (dialog->priv->display_tab.bgcolor_color_button),
bool_bgcolor_override);
/* connect signals */
g_signal_connect (G_OBJECT (dialog->priv->display_tab.bgcolor_override_check_button),
"toggled", (GCallback)cb_bgcolor_override_toggled, dialog);
g_signal_connect (G_OBJECT (dialog->priv->display_tab.bgcolor_color_button),
"color-set", G_CALLBACK (cb_bgcolor_color_set), dialog);
dialog->priv->display_tab.quality_vbox = gtk_vbox_new(FALSE, 0);
dialog->priv->display_tab.quality_frame = xfce_gtk_frame_box_new_with_content(_("Quality"), dialog->priv->display_tab.quality_vbox);
gtk_box_pack_start (GTK_BOX (display_main_vbox), dialog->priv->display_tab.quality_frame, FALSE, FALSE, 0);
dialog->priv->display_tab.quality_label = gtk_label_new (
_("With this option enabled, the maximum image-quality will be limited to the screen-size."));
gtk_label_set_line_wrap (GTK_LABEL (dialog->priv->display_tab.quality_label), TRUE);
gtk_misc_set_alignment(GTK_MISC(dialog->priv->display_tab.quality_label), 0, 0.5);
dialog->priv->display_tab.quality_button = gtk_check_button_new_with_label (_("Limit rendering quality"));
gtk_container_add (GTK_CONTAINER (dialog->priv->display_tab.quality_vbox), dialog->priv->display_tab.quality_label);
gtk_container_add (GTK_CONTAINER (dialog->priv->display_tab.quality_vbox), dialog->priv->display_tab.quality_button);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->display_tab.quality_button), bool_limit_quality);
g_signal_connect (G_OBJECT (dialog->priv->display_tab.quality_button),
"toggled", (GCallback)cb_limit_quality_check_button_toggled, dialog);
/*
* Fullscreen tab
*/
fullscreen_main_vbox = gtk_vbox_new(FALSE, 0);
fullscreen_main_lbl = gtk_label_new(_("Fullscreen"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), fullscreen_main_vbox, fullscreen_main_lbl);
dialog->priv->fullscreen_tab.thumbnail_vbox = gtk_vbox_new(FALSE, 0);
dialog->priv->fullscreen_tab.thumbnail_frame = xfce_gtk_frame_box_new_with_content(_("Thumbnails"), dialog->priv->fullscreen_tab.thumbnail_vbox);
gtk_box_pack_start (GTK_BOX (fullscreen_main_vbox), dialog->priv->fullscreen_tab.thumbnail_frame, FALSE, FALSE, 0);
dialog->priv->fullscreen_tab.hide_thumbnails_fullscreen_lbl = gtk_label_new(_("The thumbnail bar can be automatically hidden when the window is fullscreen."));
gtk_label_set_line_wrap (GTK_LABEL (dialog->priv->fullscreen_tab.hide_thumbnails_fullscreen_lbl), TRUE);
gtk_misc_set_alignment(GTK_MISC(dialog->priv->fullscreen_tab.hide_thumbnails_fullscreen_lbl), 0, 0.5);
dialog->priv->fullscreen_tab.hide_thumbnails_fullscreen_check_button = gtk_check_button_new_with_label (_("Hide thumbnail bar when fullscreen"));
gtk_box_pack_start (GTK_BOX (dialog->priv->fullscreen_tab.thumbnail_vbox), dialog->priv->fullscreen_tab.hide_thumbnails_fullscreen_lbl, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (dialog->priv->fullscreen_tab.thumbnail_vbox), dialog->priv->fullscreen_tab.hide_thumbnails_fullscreen_check_button, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->fullscreen_tab.hide_thumbnails_fullscreen_check_button),
bool_hide_thumbnails_fullscreen);
dialog->priv->fullscreen_tab.clock_vbox = gtk_vbox_new(FALSE, 0);
dialog->priv->fullscreen_tab.clock_frame = xfce_gtk_frame_box_new_with_content(_("Clock"), dialog->priv->fullscreen_tab.clock_vbox);
gtk_box_pack_start (GTK_BOX (fullscreen_main_vbox), dialog->priv->fullscreen_tab.clock_frame, FALSE, FALSE, 0);
dialog->priv->fullscreen_tab.clock_label = gtk_label_new ( _("Show an analog clock that displays the current time when the window is fullscreen"));
gtk_label_set_line_wrap (GTK_LABEL (dialog->priv->fullscreen_tab.clock_label), TRUE);
gtk_misc_set_alignment(GTK_MISC(dialog->priv->fullscreen_tab.clock_label), 0, 0.5);
dialog->priv->fullscreen_tab.clock_button = gtk_check_button_new_with_label (_("Show Fullscreen Clock"));
gtk_container_add (GTK_CONTAINER (dialog->priv->fullscreen_tab.clock_vbox), dialog->priv->fullscreen_tab.clock_label);
gtk_container_add (GTK_CONTAINER (dialog->priv->fullscreen_tab.clock_vbox), dialog->priv->fullscreen_tab.clock_button);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->fullscreen_tab.clock_button), bool_show_clock);
g_signal_connect (G_OBJECT (dialog->priv->fullscreen_tab.hide_thumbnails_fullscreen_check_button),
"toggled", (GCallback)cb_hide_thumbnails_fullscreen_check_button_toggled, dialog);
g_signal_connect (G_OBJECT (dialog->priv->fullscreen_tab.clock_button),
"toggled", (GCallback)cb_show_clock_check_button_toggled, dialog);
/*
* Slideshow tab
*/
slideshow_main_vbox = gtk_vbox_new(FALSE, 0);
slideshow_main_lbl = gtk_label_new(_("Slideshow"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), slideshow_main_vbox, slideshow_main_lbl);
dialog->priv->slideshow_tab.timeout_vbox = gtk_vbox_new(FALSE, 0);
dialog->priv->slideshow_tab.timeout_frame = xfce_gtk_frame_box_new_with_content(_("Timeout"), dialog->priv->slideshow_tab.timeout_vbox);
gtk_box_pack_start (GTK_BOX (slideshow_main_vbox), dialog->priv->slideshow_tab.timeout_frame, FALSE, FALSE, 0);
timeout_lbl = gtk_label_new(_("The time period an individual image is displayed during a slideshow\n(in seconds)"));
timeout_hscale = gtk_hscale_new_with_range(1, 60, 1);
gtk_misc_set_alignment(GTK_MISC(timeout_lbl), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(timeout_lbl), 2, 2);
gtk_box_pack_start(GTK_BOX(dialog->priv->slideshow_tab.timeout_vbox), timeout_lbl, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(dialog->priv->slideshow_tab.timeout_vbox), timeout_hscale, FALSE, TRUE, 0);
gtk_range_set_value (GTK_RANGE (timeout_hscale), (gdouble)uint_slideshow_timeout);
g_signal_connect (
G_OBJECT (timeout_hscale),
"value-changed",
(GCallback)cb_slideshow_timeout_value_changed,
dialog);
control_main_vbox = gtk_vbox_new(FALSE, 0);
control_main_lbl = gtk_label_new(_("Control"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), control_main_vbox, control_main_lbl);
dialog->priv->control_tab.scroll_vbox = gtk_vbox_new(FALSE, 0);
dialog->priv->control_tab.scroll_frame = xfce_gtk_frame_box_new_with_content(_("Scroll wheel"), dialog->priv->control_tab.scroll_vbox);
gtk_box_pack_start (GTK_BOX (control_main_vbox), dialog->priv->control_tab.scroll_frame, FALSE, FALSE, 0);
dialog->priv->control_tab.zoom_invert_check_button = gtk_check_button_new_with_label (_("Invert zoom direction"));
gtk_container_add (GTK_CONTAINER (dialog->priv->control_tab.scroll_vbox), dialog->priv->control_tab.zoom_invert_check_button);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->control_tab.zoom_invert_check_button), bool_invert_zoom_direction);
g_signal_connect (
G_OBJECT (dialog->priv->control_tab.zoom_invert_check_button),
"toggled",
(GCallback)cb_invert_zoom_direction_check_button_toggled,
dialog);
/*
* Behaviour tab
*/
behaviour_main_vbox = gtk_vbox_new(FALSE, 0);
behaviour_main_lbl = gtk_label_new(_("Behaviour"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), behaviour_main_vbox, behaviour_main_lbl);
/********************************************/
dialog->priv->behaviour_tab.startup_vbox = gtk_vbox_new(FALSE, 0);
dialog->priv->behaviour_tab.startup_frame = xfce_gtk_frame_box_new_with_content(_("Startup"), dialog->priv->behaviour_tab.startup_vbox);
gtk_box_pack_start (GTK_BOX (behaviour_main_vbox), dialog->priv->behaviour_tab.startup_frame, FALSE, FALSE, 0);
dialog->priv->behaviour_tab.maximize_window_on_startup_check_button = gtk_check_button_new_with_label (_("Maximize window on startup when opening an image"));
gtk_container_add (GTK_CONTAINER (dialog->priv->behaviour_tab.startup_vbox), dialog->priv->behaviour_tab.maximize_window_on_startup_check_button);
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (dialog->priv->behaviour_tab.maximize_window_on_startup_check_button),
bool_maximize_on_startup);
dialog->priv->behaviour_tab.wrap_images_check_button = gtk_check_button_new_with_label (_("Wrap around images"));
gtk_container_add (GTK_CONTAINER (dialog->priv->behaviour_tab.startup_vbox), dialog->priv->behaviour_tab.wrap_images_check_button);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->behaviour_tab.wrap_images_check_button),
bool_wrap_images);
g_signal_connect (
G_OBJECT (dialog->priv->behaviour_tab.wrap_images_check_button),
"toggled",
(GCallback)cb_wrap_images_check_button_toggled,
dialog);
g_signal_connect (
G_OBJECT (dialog->priv->behaviour_tab.maximize_window_on_startup_check_button),
"toggled",
(GCallback)cb_maximize_on_startup_check_button_toggled,
dialog);
/********************************************/
dialog->priv->behaviour_tab.desktop_vbox = gtk_vbox_new(FALSE, 4);
dialog->priv->behaviour_tab.desktop_frame = xfce_gtk_frame_box_new_with_content(
_("Desktop"),
dialog->priv->behaviour_tab.desktop_vbox);
gtk_box_pack_start (
GTK_BOX (behaviour_main_vbox),
dialog->priv->behaviour_tab.desktop_frame,
FALSE,
FALSE,
0);
behaviour_desktop_lbl = gtk_label_new(NULL);
gtk_label_set_markup (
GTK_LABEL (behaviour_desktop_lbl),
_("Configure which system is currently managing your desktop.\n"
"This setting determines the method <i>Ristretto</i> will use\n"
"to configure the desktop wallpaper."));
gtk_misc_set_alignment(
GTK_MISC(behaviour_desktop_lbl),
0,
0.5);
gtk_box_pack_start (
GTK_BOX (dialog->priv->behaviour_tab.desktop_vbox),
behaviour_desktop_lbl,
FALSE,
FALSE,
0);
dialog->priv->behaviour_tab.choose_desktop_combo_box =
gtk_combo_box_new_text();
gtk_box_pack_start (
GTK_BOX (dialog->priv->behaviour_tab.desktop_vbox),
dialog->priv->behaviour_tab.choose_desktop_combo_box,
FALSE,
FALSE,
0);
gtk_combo_box_insert_text(
GTK_COMBO_BOX (dialog->priv->behaviour_tab.choose_desktop_combo_box),
DESKTOP_TYPE_NONE,
_("None"));
gtk_combo_box_insert_text (
GTK_COMBO_BOX (dialog->priv->behaviour_tab.choose_desktop_combo_box),
DESKTOP_TYPE_XFCE,
_("Xfce"));
gtk_combo_box_insert_text (
GTK_COMBO_BOX (dialog->priv->behaviour_tab.choose_desktop_combo_box),
DESKTOP_TYPE_GNOME,
_("GNOME"));
if (str_desktop_type != NULL)
{
if (0 == g_ascii_strcasecmp (str_desktop_type, "xfce"))
{
gtk_combo_box_set_active (
GTK_COMBO_BOX (dialog->priv->behaviour_tab.choose_desktop_combo_box),
DESKTOP_TYPE_XFCE);
}
else
{
if (0 == g_ascii_strcasecmp (str_desktop_type, "gnome"))
{
gtk_combo_box_set_active (
GTK_COMBO_BOX (dialog->priv->behaviour_tab.choose_desktop_combo_box),
DESKTOP_TYPE_GNOME);
}
else
{
gtk_combo_box_set_active (
GTK_COMBO_BOX (dialog->priv->behaviour_tab.choose_desktop_combo_box),
DESKTOP_TYPE_NONE);
}
}
}
else
{
/* Default, set it to xfce */
gtk_combo_box_set_active (
GTK_COMBO_BOX (dialog->priv->behaviour_tab.choose_desktop_combo_box),
DESKTOP_TYPE_XFCE);
}
g_signal_connect (
G_OBJECT(dialog->priv->behaviour_tab.choose_desktop_combo_box),
"changed",
(GCallback)cb_choose_desktop_combo_box_changed,
dialog);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), notebook);
gtk_widget_show_all (notebook);
/* Window should not be resizable */
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_OK);
}
