static void scale_set_default_values( GtkScale *scale )
{
gtk_range_set_update_policy (GTK_RANGE (scale),
GTK_UPDATE_CONTINUOUS);
gtk_scale_set_digits (scale, 1);
gtk_scale_set_value_pos (scale, GTK_POS_TOP);
gtk_scale_set_draw_value (scale, TRUE);
}
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;
}
GtkWidget * AddHScaler( GtkAdjustment * adj,GtkWidget * parent,int digit )
{
GtkWidget * HS;
HS=gtk_hscale_new( adj );
gtk_widget_set_name( HS,"HS" );
gtk_widget_show( HS );
if ( parent ) gtk_box_pack_start( GTK_BOX( parent ),HS,TRUE,TRUE,0 );
gtk_scale_set_value_pos( GTK_SCALE( HS ),GTK_POS_RIGHT );
gtk_scale_set_digits( GTK_SCALE( HS ),digit );
return HS;
}
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;
}
VolBox *lamixer_volbox_new(const gchar *str, const gint mono, const gint mute, const glong minrange, const glong maxrange, snd_mixer_elem_t *elem, guint voltype)
{
VolBox *volumebox;
volumebox = g_malloc(sizeof(VolBox));
volumebox->minrange = minrange;
volumebox->maxrange = maxrange;
volumebox->type = voltype;
volumebox->volelem = elem;
volumebox->volbox = gtk_vbox_new(FALSE,0);
volumebox->volbarbox = gtk_hbox_new(FALSE,0);
volumebox->vollabel = gtk_label_new(str);
volumebox->volbar = gtk_vscale_new_with_range(minrange,maxrange,1.0);
gtk_range_set_inverted(GTK_RANGE(volumebox->volbar), TRUE);
gtk_scale_set_digits(GTK_SCALE(volumebox->volbar),0);
gtk_scale_set_value_pos(GTK_SCALE(volumebox->volbar),GTK_POS_BOTTOM);
//FIXME: Need any other method to set size
gtk_widget_set_size_request(GTK_WIDGET(volumebox->volbar),0,200);
if (!mono) {
volumebox->rvolbar = gtk_vscale_new_with_range(minrange,maxrange,1.0);
gtk_scale_set_digits(GTK_SCALE(volumebox->rvolbar),0);
gtk_range_set_inverted(GTK_RANGE(volumebox->rvolbar), TRUE);
gtk_scale_set_value_pos(GTK_SCALE(volumebox->rvolbar),GTK_POS_BOTTOM);
gtk_widget_set_size_request(GTK_WIDGET(volumebox->rvolbar),0,200);
volumebox->lockswitch = gtk_check_button_new_with_label("Lock");
}
else {
volumebox->rvolbar = NULL;
volumebox->lockswitch = NULL;
}
if (mute)
volumebox->muteswitch = gtk_check_button_new_with_label("Mute");
else
volumebox->muteswitch = NULL;
return volumebox;
}
static GObject *constructor(GType gtype, guint n_properties, GObjectConstructParam *properties) {
GObject *obj;
obj = G_OBJECT_CLASS(roccat_volume_scale_parent_class)->constructor(gtype, n_properties, properties);
gtk_range_set_range(GTK_RANGE(obj), -100.0, 10.0);
gtk_range_set_increments(GTK_RANGE(obj), 1.0, 10.0);
gtk_scale_set_draw_value(GTK_SCALE(obj), TRUE);
gtk_scale_set_value_pos(GTK_SCALE(obj), GTK_POS_RIGHT);
g_signal_connect(G_OBJECT(obj), "format-value", G_CALLBACK(format_value_cb), NULL);
return obj;
}
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;
}
int main (int argc, char ** argv)
{
GtkWidget *window;
GtkWidget *cpu;
GtkWidget *fixed;
GtkWidget *scale;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "CPU widget");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window), 200, 180);
//gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
fixed = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed);
cpu = gtk_cpu_new();
gtk_fixed_put(GTK_FIXED(fixed), cpu, 30, 40);
scale = gtk_vscale_new_with_range(0.0, 100.0, 1.0);
gtk_range_set_inverted(GTK_RANGE(scale), TRUE);
gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_TOP);
gtk_widget_set_size_request(scale, 50, 120);
gtk_fixed_put(GTK_FIXED(fixed), scale, 130, 20);
g_signal_connect(G_OBJECT(scale), "value_changed", G_CALLBACK(set_value), (gpointer) cpu);
gtk_widget_show(cpu);
gtk_widget_show(fixed);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
/**
* Updates the alignment of the volume text which is shown on the
* volume popup_window (left click) around the scroll bar.
*/
void update_vol_text() {
gboolean show = TRUE;
if (g_key_file_has_key(keyFile,"PNMixer","DisplayTextVolume",NULL))
show = g_key_file_get_boolean(keyFile,"PNMixer","DisplayTextVolume",NULL);
if (show) {
GtkPositionType pos = GTK_POS_RIGHT;
if (g_key_file_has_key(keyFile,"PNMixer","TextVolumePosition",NULL)) {
gint pi = g_key_file_get_integer(keyFile,"PNMixer","TextVolumePosition",NULL);
pos =
pi==0?GTK_POS_TOP:
pi==1?GTK_POS_BOTTOM:
pi==2?GTK_POS_LEFT:
GTK_POS_RIGHT;
}
gtk_scale_set_draw_value (GTK_SCALE (vol_scale), TRUE);
gtk_scale_set_value_pos (GTK_SCALE (vol_scale), pos);
}
else
gtk_scale_set_draw_value (GTK_SCALE (vol_scale), FALSE);
}
int main(int argc, char *argv[]) {
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect_swapped(G_OBJECT(window), "delete_event", G_CALLBACK(gtk_main_quit), G_OBJECT(window));
gtk_widget_show(window);
GtkWidget *vscale = gtk_vscale_new_with_range(0, 10, 1);
// gtk_scale_set_draw_value(GTK_SCALE(vscale), FALSE);
gtk_scale_set_digits(GTK_SCALE(vscale), 4);
gtk_scale_set_value_pos(GTK_SCALE(vscale), GTK_POS_LEFT);
gtk_container_add(GTK_CONTAINER(window), vscale);
gtk_widget_show(vscale);
gtk_main();
return 0;
}
/**
* Updates the alignment of the volume text which is shown on the
* volume popup_window (left click) around the scroll bar.
*/
void
update_vol_text(void)
{
gboolean show;
show = prefs_get_boolean("DisplayTextVolume", TRUE);
if (show) {
gint pi;
GtkPositionType pos;
pi = prefs_get_integer("TextVolumePosition", 0);
pos = pi == 0 ? GTK_POS_TOP : pi == 1 ? GTK_POS_BOTTOM : pi ==
2 ? GTK_POS_LEFT : GTK_POS_RIGHT;
gtk_scale_set_draw_value(GTK_SCALE(vol_scale), TRUE);
gtk_scale_set_value_pos(GTK_SCALE(vol_scale), pos);
} else
gtk_scale_set_draw_value(GTK_SCALE(vol_scale), FALSE);
}
void Dialog::addSlider(GtkWidget* vbox, const char* name, int& data, gboolean draw_value, const char* low, const char* high, double value, double lower, double upper, double step_increment, double page_increment)
{
#if 0
if(draw_value == FALSE)
{
GtkWidget* hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox2);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox2), FALSE, FALSE, 0);
{
GtkWidget* label = gtk_label_new (low);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
}
{
GtkWidget* label = gtk_label_new (high);
gtk_widget_show (label);
gtk_box_pack_end (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
}
}
#endif
// adjustment
GtkObject* adj = gtk_adjustment_new(value, lower, upper, step_increment, page_increment, 0);
AddIntAdjustmentData(*GTK_ADJUSTMENT(adj), IntImportCaller(data), IntExportCaller(data));
// scale
GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 1.0, 0.0);
gtk_widget_show(alignment);
GtkWidget* scale = gtk_hscale_new(GTK_ADJUSTMENT(adj));
gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_LEFT);
gtk_widget_show(scale);
gtk_container_add(GTK_CONTAINER(alignment), scale);
gtk_scale_set_draw_value(GTK_SCALE (scale), draw_value);
gtk_scale_set_digits(GTK_SCALE (scale), 0);
GtkTable* row = DialogRow_new(name, alignment);
DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
}
static GtkWidget *
volume_create_slider(volume_priv *c)
{
GtkWidget *slider, *win;
GtkWidget *frame;
win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(win), 180, 180);
gtk_window_set_decorated(GTK_WINDOW(win), FALSE);
gtk_window_set_resizable(GTK_WINDOW(win), FALSE);
gtk_container_set_border_width(GTK_CONTAINER(win), 1);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(win), TRUE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(win), TRUE);
gtk_window_set_position(GTK_WINDOW(win), GTK_WIN_POS_MOUSE);
gtk_window_stick(GTK_WINDOW(win));
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(win), frame);
gtk_container_set_border_width(GTK_CONTAINER(frame), 1);
slider = gtk_vscale_new_with_range(0.0, 100.0, 1.0);
gtk_widget_set_size_request(slider, 25, 82);
gtk_scale_set_draw_value(GTK_SCALE(slider), TRUE);
gtk_scale_set_value_pos(GTK_SCALE(slider), GTK_POS_BOTTOM);
gtk_scale_set_digits(GTK_SCALE(slider), 0);
gtk_range_set_inverted(GTK_RANGE(slider), TRUE);
gtk_range_set_value(GTK_RANGE(slider), ((meter_priv *) c)->level);
DBG("meter->level %f\n", ((meter_priv *) c)->level);
g_signal_connect(G_OBJECT(slider), "value_changed",
G_CALLBACK(slider_changed), c);
g_signal_connect(G_OBJECT(slider), "enter-notify-event",
G_CALLBACK(crossed), (gpointer)c);
g_signal_connect(G_OBJECT(slider), "leave-notify-event",
G_CALLBACK(crossed), (gpointer)c);
gtk_container_add(GTK_CONTAINER(frame), slider);
c->slider = slider;
return win;
}
static GtkWidget * create_slider (const char * name, int band, GtkWidget * hbox)
{
GtkWidget * vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
GtkWidget * label = gtk_label_new (name);
gtk_label_set_angle ((GtkLabel *) label, 90);
gtk_box_pack_start ((GtkBox *) vbox, label, TRUE, FALSE, 0);
GtkWidget * slider = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
-EQUALIZER_MAX_GAIN, EQUALIZER_MAX_GAIN, 1);
gtk_scale_set_draw_value ((GtkScale *) slider, TRUE);
gtk_scale_set_value_pos ((GtkScale *) slider, GTK_POS_BOTTOM);
gtk_widget_set_size_request (slider, -1, 120);
g_object_set_data ((GObject *) slider, "band", GINT_TO_POINTER (band));
g_signal_connect ((GObject *) slider, "format-value", (GCallback) format_value, NULL);
g_signal_connect ((GObject *) slider, "value-changed", (GCallback) slider_moved, NULL);
gtk_box_pack_start ((GtkBox *) vbox, slider, FALSE, FALSE, 0);
gtk_box_pack_start ((GtkBox *) hbox, vbox, FALSE, FALSE, 0);
return slider;
}
/* Configure the appearance of the text that is shown around the volume slider,
* according to the current preferences.
*/
static void
configure_vol_text(GtkScale *vol_scale)
{
gboolean enabled;
gint position;
GtkPositionType gtk_position;
enabled = prefs_get_boolean("DisplayTextVolume", TRUE);
position = prefs_get_integer("TextVolumePosition", 0);
gtk_position =
position == 0 ? GTK_POS_TOP :
position == 1 ? GTK_POS_BOTTOM :
position == 2 ? GTK_POS_LEFT :
GTK_POS_RIGHT;
if (enabled) {
gtk_scale_set_draw_value(vol_scale, TRUE);
gtk_scale_set_value_pos(vol_scale, gtk_position);
} else {
gtk_scale_set_draw_value(vol_scale, FALSE);
}
}
void Scale::setValuePos(PositionType pos)
{
GtkPositionType p;
switch(pos) {
case POS_LEFT:
p = GTK_POS_LEFT;
break;
case POS_RIGHT:
p = GTK_POS_RIGHT;
break;
case POS_TOP:
p = GTK_POS_TOP;
break;
case POS_BOTTOM:
p = GTK_POS_BOTTOM;
break;
default:
fprintf(stderr, "PositionType is incorrect\n");
p = GTK_POS_LEFT; // TODO: Error cond.
}
gtk_scale_set_value_pos(GTK_SCALE(widget), p);
}
/** \brief Create a customized GtkScale for \a resource
*
* \param[in] resource resource name without the video \a chip name prefix
* \param[in] low lower bound
* \param[in] high upper bound
* \param[in] step step used to increase/decrease slider value
* \param[in] minimal reduce slider size to be used in the statusbar
*
* \return GtkScale
*/
static GtkWidget *create_slider(
const char *resource,
int low, int high, int step,
gboolean minimal)
{
GtkWidget *scale;
GtkCssProvider *provider;
GtkStyleContext *context;
GError *err = NULL;
scale = vice_gtk3_resource_scale_int_new(resource,
GTK_ORIENTATION_HORIZONTAL, low, high, step);
gtk_widget_set_hexpand(scale, TRUE);
gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_RIGHT);
vice_gtk3_resource_scale_int_set_marks(scale, step);
if (minimal) {
provider = gtk_css_provider_new();
gtk_css_provider_load_from_data(provider, SLIDER_CSS, -1, &err);
if (err != NULL) {
fprintf(stderr, "CSS error: %s\n", err->message);
g_error_free(err);
}
context = gtk_widget_get_style_context(scale);
if (context != NULL) {
gtk_style_context_add_provider(context,
GTK_STYLE_PROVIDER(provider),
GTK_STYLE_PROVIDER_PRIORITY_USER);
}
}
/* gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE); */
return scale;
}
void
gradient_editor_split_uniformly_cmd_callback (GtkAction *action,
gpointer data)
{
GimpGradientEditor *editor = GIMP_GRADIENT_EDITOR (data);
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (data);
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *scale;
GtkObject *scale_data;
const gchar *title;
const gchar *desc;
if (editor->control_sel_l == editor->control_sel_r)
{
title = _("Split Segment Uniformly");
desc = _("Split Gradient Segment Uniformly");
}
else
{
title = _("Split Segments Uniformly");
desc = _("Split Gradient Segments Uniformly");
}
dialog =
gimp_viewable_dialog_new (GIMP_VIEWABLE (data_editor->data),
data_editor->context,
title, "gimp-gradient-segment-split-uniformly",
GIMP_STOCK_GRADIENT, desc,
GTK_WIDGET (editor),
gimp_standard_help_func,
GIMP_HELP_GRADIENT_EDITOR_SPLIT_UNIFORM,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("Split"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
g_signal_connect (dialog, "response",
G_CALLBACK (gradient_editor_split_uniform_response),
editor);
/* The main vbox */
vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
/* Instructions */
if (editor->control_sel_l == editor->control_sel_r)
label = gtk_label_new (_("Select the number of uniform parts\n"
"in which to split the selected segment."));
else
label = gtk_label_new (_("Select the number of uniform parts\n"
"in which to split the segments in the selection."));
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
/* Scale */
editor->split_parts = 2;
scale_data = gtk_adjustment_new (2.0, 2.0, 21.0, 1.0, 1.0, 1.0);
scale = gtk_hscale_new (GTK_ADJUSTMENT (scale_data));
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 4);
gtk_widget_show (scale);
g_signal_connect (scale_data, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
&editor->split_parts);
gtk_widget_set_sensitive (GTK_WIDGET (editor), FALSE);
gimp_ui_manager_update (GIMP_EDITOR (editor)->ui_manager,
GIMP_EDITOR (editor)->popup_data);
gtk_widget_show (dialog);
}
GtkWidget*
create_threshold_dialog (void)
{
GtkWidget *threshold_dialog;
GtkWidget *dialogVbox;
GtkWidget *allButButtonsVbox;
GtkWidget *settingsOuterHbox;
GtkWidget *settingsOuterVbox;
GtkWidget *minValueVbox;
GtkWidget *minValueLabel;
GtkWidget *minValueHbox;
GtkWidget *minValueSlider;
GtkObject *minValueSpinner_adj;
GtkWidget *minValueSpinner;
GtkWidget *maxValueVbox;
GtkWidget *maxValueLabel;
GtkWidget *maxValueHbox;
GtkWidget *maxValueSlider;
GtkObject *maxValueSpinner_adj;
GtkWidget *maxValueSpinner;
GtkWidget *outputValuesHbox;
GtkWidget *outputValuesLabel;
GtkWidget *outputValuesMenu;
GtkWidget *debugHbox;
GtkWidget *debugLabel;
GtkObject *debugSpinButton_adj;
GtkWidget *debugSpinButton;
GtkWidget *previewFrame;
GtkWidget *previewAlignment;
GtkWidget *previewVbox;
GtkWidget *previewControlHbox;
GtkWidget *previewOutputMenu;
GtkWidget *previewSlider;
GtkWidget *previewVideo;
GtkWidget *previewLabel;
GtkWidget *dialogButtonBox;
GtkWidget *cancelButton;
GtkWidget *okButton;
threshold_dialog = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (threshold_dialog), QT_TR_NOOP("Threshold"));
gtk_window_set_type_hint (GTK_WINDOW (threshold_dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
dialogVbox = GTK_DIALOG (threshold_dialog)->vbox;
gtk_widget_show (dialogVbox);
allButButtonsVbox = gtk_vbox_new (FALSE, 12);
gtk_widget_show (allButButtonsVbox);
gtk_box_pack_start (GTK_BOX (dialogVbox), allButButtonsVbox, TRUE, TRUE, 0);
settingsOuterHbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (settingsOuterHbox);
gtk_box_pack_start (GTK_BOX (allButButtonsVbox), settingsOuterHbox, FALSE, TRUE, 0);
settingsOuterVbox = gtk_vbox_new (FALSE, 12);
gtk_widget_show (settingsOuterVbox);
gtk_box_pack_start (GTK_BOX (settingsOuterHbox), settingsOuterVbox, TRUE, TRUE, 0);
minValueVbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (minValueVbox);
gtk_box_pack_start (GTK_BOX (settingsOuterVbox), minValueVbox, FALSE, FALSE, 0);
minValueLabel = gtk_label_new (QT_TR_NOOP("Minimum value to be in-range:"));
gtk_widget_show (minValueLabel);
gtk_box_pack_start (GTK_BOX (minValueVbox), minValueLabel, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (minValueLabel), 0.5, 1);
gtk_misc_set_padding (GTK_MISC (minValueLabel), 0, 8);
minValueHbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (minValueHbox);
gtk_box_pack_start (GTK_BOX (minValueVbox), minValueHbox, TRUE, TRUE, 0);
#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE
minValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 255, 1, 1, 0)));
#else
minValueSpinner_adj = gtk_adjustment_new (0, 0, 255, 1, 1, 0);
minValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (minValueSpinner_adj));
#endif
gtk_widget_show (minValueSlider);
gtk_box_pack_start (GTK_BOX (minValueHbox), minValueSlider, TRUE, TRUE, 0);
gtk_scale_set_draw_value (GTK_SCALE (minValueSlider), FALSE);
gtk_scale_set_value_pos (GTK_SCALE (minValueSlider), GTK_POS_LEFT);
gtk_scale_set_digits (GTK_SCALE (minValueSlider), 0);
#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE
minValueSpinner_adj = gtk_adjustment_new (0, 0, 255, 1, 10, 10);
#endif
minValueSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (minValueSpinner_adj), 1, 0);
gtk_widget_show (minValueSpinner);
gtk_box_pack_start (GTK_BOX (minValueHbox), minValueSpinner, FALSE, TRUE, 0);
maxValueVbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (maxValueVbox);
gtk_box_pack_start (GTK_BOX (settingsOuterVbox), maxValueVbox, FALSE, FALSE, 0);
maxValueLabel = gtk_label_new (QT_TR_NOOP("Maximum value to be in-range:"));
gtk_widget_show (maxValueLabel);
gtk_box_pack_start (GTK_BOX (maxValueVbox), maxValueLabel, FALSE, FALSE, 0);
maxValueHbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (maxValueHbox);
gtk_box_pack_start (GTK_BOX (maxValueVbox), maxValueHbox, TRUE, TRUE, 0);
#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE
maxValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (255, 0, 255, 1, 1, 0)));
#else
maxValueSpinner_adj = gtk_adjustment_new (255, 0, 255, 1, 1, 0);
maxValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (maxValueSpinner_adj));
#endif
gtk_widget_show (maxValueSlider);
gtk_box_pack_start (GTK_BOX (maxValueHbox), maxValueSlider, TRUE, TRUE, 0);
gtk_scale_set_draw_value (GTK_SCALE (maxValueSlider), FALSE);
gtk_scale_set_value_pos (GTK_SCALE (maxValueSlider), GTK_POS_LEFT);
gtk_scale_set_digits (GTK_SCALE (maxValueSlider), 0);
#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE
maxValueSpinner_adj = gtk_adjustment_new (255, 0, 255, 1, 10, 10);
#endif
maxValueSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (maxValueSpinner_adj), 1, 0);
gtk_widget_show (maxValueSpinner);
gtk_box_pack_start (GTK_BOX (maxValueHbox), maxValueSpinner, FALSE, TRUE, 0);
outputValuesHbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (outputValuesHbox);
gtk_box_pack_start (GTK_BOX (settingsOuterVbox), outputValuesHbox, TRUE, TRUE, 0);
outputValuesLabel = gtk_label_new (QT_TR_NOOP("Output values: "));
gtk_widget_show (outputValuesLabel);
gtk_box_pack_start (GTK_BOX (outputValuesHbox), outputValuesLabel, FALSE, FALSE, 0);
outputValuesMenu = gtk_combo_box_new_text ();
gtk_widget_show (outputValuesMenu);
gtk_box_pack_start (GTK_BOX (outputValuesHbox), outputValuesMenu, TRUE, TRUE, 0);
gtk_combo_box_append_text (GTK_COMBO_BOX (outputValuesMenu), QT_TR_NOOP("In-range values go black, out-of-range values go white"));
gtk_combo_box_append_text (GTK_COMBO_BOX (outputValuesMenu), QT_TR_NOOP("In-range values go white, out-of-range values go black"));
debugHbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (debugHbox);
gtk_box_pack_start (GTK_BOX (settingsOuterVbox), debugHbox, TRUE, TRUE, 0);
debugLabel = gtk_label_new (QT_TR_NOOP("Debugging settings (bits): "));
gtk_widget_show (debugLabel);
gtk_box_pack_start (GTK_BOX (debugHbox), debugLabel, FALSE, FALSE, 0);
debugSpinButton_adj = gtk_adjustment_new (0, 0, 16777215, 1, 10, 10);
debugSpinButton = gtk_spin_button_new (GTK_ADJUSTMENT (debugSpinButton_adj), 1, 0);
gtk_widget_show (debugSpinButton);
gtk_box_pack_start (GTK_BOX (debugHbox), debugSpinButton, TRUE, TRUE, 0);
previewFrame = gtk_frame_new (NULL);
gtk_widget_show (previewFrame);
gtk_box_pack_start (GTK_BOX (allButButtonsVbox), previewFrame, TRUE, TRUE, 0);
previewAlignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (previewAlignment);
gtk_container_add (GTK_CONTAINER (previewFrame), previewAlignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (previewAlignment), 0, 8, 6, 8);
previewVbox = gtk_vbox_new (FALSE, 5);
gtk_widget_show (previewVbox);
gtk_container_add (GTK_CONTAINER (previewAlignment), previewVbox);
previewControlHbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (previewControlHbox);
gtk_box_pack_start (GTK_BOX (previewVbox), previewControlHbox, TRUE, TRUE, 0);
previewOutputMenu = gtk_combo_box_new_text ();
gtk_widget_show (previewOutputMenu);
gtk_box_pack_start (GTK_BOX (previewControlHbox), previewOutputMenu, FALSE, TRUE, 0);
previewSlider = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 99, 1, 1, 1)));
gtk_widget_show (previewSlider);
gtk_box_pack_start (GTK_BOX (previewControlHbox), previewSlider, TRUE, TRUE, 0);
gtk_scale_set_digits (GTK_SCALE (previewSlider), 0);
previewVideo = gtk_drawing_area_new ();
gtk_widget_show (previewVideo);
gtk_box_pack_start (GTK_BOX (previewVbox), previewVideo, TRUE, TRUE, 0);
gtk_widget_set_size_request (previewVideo, 30, 30);
gtk_widget_set_events (previewVideo, GDK_BUTTON1_MOTION_MASK | GDK_BUTTON_PRESS_MASK);
previewLabel = gtk_label_new (QT_TR_NOOP("Preview"));
gtk_widget_show (previewLabel);
gtk_frame_set_label_widget (GTK_FRAME (previewFrame), previewLabel);
dialogButtonBox = GTK_DIALOG (threshold_dialog)->action_area;
gtk_widget_show (dialogButtonBox);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialogButtonBox), GTK_BUTTONBOX_END);
cancelButton = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelButton);
gtk_dialog_add_action_widget (GTK_DIALOG (threshold_dialog), cancelButton, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelButton, GTK_CAN_DEFAULT);
okButton = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okButton);
gtk_dialog_add_action_widget (GTK_DIALOG (threshold_dialog), okButton, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okButton, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (threshold_dialog, threshold_dialog, "threshold_dialog");
GLADE_HOOKUP_OBJECT_NO_REF (threshold_dialog, dialogVbox, "dialogVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, allButButtonsVbox, "allButButtonsVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, settingsOuterHbox, "settingsOuterHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, settingsOuterVbox, "settingsOuterVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueVbox, "minValueVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueLabel, "minValueLabel");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueHbox, "minValueHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueSlider, "minValueSlider");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueSpinner, "minValueSpinner");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueVbox, "maxValueVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueLabel, "maxValueLabel");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueHbox, "maxValueHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueSlider, "maxValueSlider");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueSpinner, "maxValueSpinner");
GLADE_HOOKUP_OBJECT (threshold_dialog, outputValuesHbox, "outputValuesHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, outputValuesLabel, "outputValuesLabel");
GLADE_HOOKUP_OBJECT (threshold_dialog, outputValuesMenu, "outputValuesMenu");
GLADE_HOOKUP_OBJECT (threshold_dialog, debugHbox, "debugHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, debugLabel, "debugLabel");
GLADE_HOOKUP_OBJECT (threshold_dialog, debugSpinButton, "debugSpinButton");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewFrame, "previewFrame");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewAlignment, "previewAlignment");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewVbox, "previewVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewControlHbox, "previewControlHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewOutputMenu, "previewOutputMenu");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewSlider, "previewSlider");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewVideo, "previewVideo");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewLabel, "previewLabel");
GLADE_HOOKUP_OBJECT_NO_REF (threshold_dialog, dialogButtonBox, "dialogButtonBox");
GLADE_HOOKUP_OBJECT (threshold_dialog, cancelButton, "cancelButton");
GLADE_HOOKUP_OBJECT (threshold_dialog, okButton, "okButton");
return threshold_dialog;
}
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 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));
}
GtkWidget*
create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *vbox3;
GtkWidget *label1;
GtkWidget *hscaleContrast;
GtkWidget *label2;
GtkWidget *hscaleBright;
GtkWidget *vbox2;
GtkWidget *checkLuma;
GtkWidget *checkbuttonU;
GtkWidget *checkbuttonV;
GtkWidget *hscale1;
GtkWidget *drawingarea1;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Contrast"));
gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);
vbox3 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox3);
gtk_box_pack_start (GTK_BOX (hbox1), vbox3, TRUE, TRUE, 0);
label1 = gtk_label_new (QT_TR_NOOP("Contrast"));
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (vbox3), label1, FALSE, FALSE, 0);
hscaleContrast = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.5, 1.5, 0.1, 0.1, 0)));
gtk_widget_show (hscaleContrast);
gtk_box_pack_start (GTK_BOX (vbox3), hscaleContrast, FALSE, TRUE, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleContrast), GTK_POS_LEFT);
label2 = gtk_label_new (QT_TR_NOOP("Brightness"));
gtk_widget_show (label2);
gtk_box_pack_start (GTK_BOX (vbox3), label2, FALSE, FALSE, 0);
hscaleBright = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, -127, 127, 1, 1, 0)));
gtk_widget_show (hscaleBright);
gtk_box_pack_start (GTK_BOX (vbox3), hscaleBright, FALSE, TRUE, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleBright), GTK_POS_LEFT);
gtk_scale_set_digits (GTK_SCALE (hscaleBright), 0);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (hbox1), vbox2, TRUE, TRUE, 0);
checkLuma = gtk_check_button_new_with_mnemonic (QT_TR_NOOP("Luma"));
gtk_widget_show (checkLuma);
gtk_box_pack_start (GTK_BOX (vbox2), checkLuma, FALSE, FALSE, 0);
checkbuttonU = gtk_check_button_new_with_mnemonic (QT_TR_NOOP("Chroma U"));
gtk_widget_show (checkbuttonU);
gtk_box_pack_start (GTK_BOX (vbox2), checkbuttonU, FALSE, FALSE, 0);
checkbuttonV = gtk_check_button_new_with_mnemonic (QT_TR_NOOP("Chroma v"));
gtk_widget_show (checkbuttonV);
gtk_box_pack_start (GTK_BOX (vbox2), checkbuttonV, FALSE, FALSE, 0);
hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 99, 1, 1, 0)));
gtk_widget_show (hscale1);
gtk_box_pack_start (GTK_BOX (vbox1), hscale1, TRUE, TRUE, 0);
drawingarea1 = gtk_drawing_area_new ();
gtk_widget_show (drawingarea1);
gtk_box_pack_start (GTK_BOX (vbox1), drawingarea1, TRUE, TRUE, 0);
gtk_widget_set_size_request (drawingarea1, -1, 300);
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (dialog1, vbox3, "vbox3");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, hscaleContrast, "hscaleContrast");
GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
GLADE_HOOKUP_OBJECT (dialog1, hscaleBright, "hscaleBright");
GLADE_HOOKUP_OBJECT (dialog1, vbox2, "vbox2");
GLADE_HOOKUP_OBJECT (dialog1, checkLuma, "checkLuma");
GLADE_HOOKUP_OBJECT (dialog1, checkbuttonU, "checkbuttonU");
GLADE_HOOKUP_OBJECT (dialog1, checkbuttonV, "checkbuttonV");
GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1");
GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
void uade_gui_seek_subsong(int to)
{
GtkWidget *seek_button_box;
GtkWidget *prev_next_button_box;
GtkWidget *seek_button_vbox;
GtkWidget *seek_slider_box;
GtkWidget *hscale;
GtkWidget *prev_button;
GtkWidget *prev_button_frame;
GtkWidget *frame;
GtkWidget *maxsong_label;
GtkWidget *next_button,*ffwd_button;
GtkWidget *ffwd_button_frame;
if (!uade_thread_running) {
fprintf(stderr, "uade: BUG! Seek not possible.\n");
return;
}
if (seekpopup == NULL) {
/* uade's subsong popup */
seekpopup = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_window_set_title(GTK_WINDOW(seekpopup), "UADE seek subsong");
gtk_window_set_position(GTK_WINDOW(seekpopup), GTK_WIN_POS_MOUSE);
gtk_container_set_border_width(GTK_CONTAINER(seekpopup), 0);
gtk_window_set_policy(GTK_WINDOW(seekpopup), FALSE, FALSE, FALSE);
gtk_signal_connect(GTK_OBJECT(seekpopup), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&seekpopup);
gtk_signal_connect(GTK_OBJECT(seekpopup), "focus_out_event",
GTK_SIGNAL_FUNC(focus_out_event), NULL);
gtk_widget_realize(seekpopup);
gdk_window_set_decorations(seekpopup->window, 0);
/* define Slider code, will be used by all styles of the popup */
if (uade_get_max_subsong(-1) >= 0) {
subsong_adj =
gtk_adjustment_new(uade_get_cur_subsong(0), uade_get_min_subsong(0),
uade_get_max_subsong(0), 1, 0, 0); /*our scale for the subsong slider */
maxsong_label =
gtk_label_new(g_strdup_printf("%d", uade_get_max_subsong(0))); /* until we can't get the reliable maximum number of subsongs this has to do :-) */
gtk_widget_set_usize(maxsong_label, 24, -1);
} else {
subsong_adj =
gtk_adjustment_new(uade_get_cur_subsong(0), uade_get_min_subsong(0),
(uade_get_max_subsong(0)) + 10, 1, 0, 0); /*our scale for the subsong slider */
/*currently: min - min+10 */
maxsong_label = gtk_label_new("..."); /* until we can't get the reliable maximum number of subsongs this has to do :-) */
gtk_widget_set_usize(maxsong_label, 24, -1);
}
hscale = gtk_hscale_new(GTK_ADJUSTMENT(subsong_adj));
gtk_widget_set_usize(hscale, 160, -1);
gtk_scale_set_digits(GTK_SCALE(hscale), 0);
gtk_scale_set_value_pos(GTK_SCALE(hscale), GTK_POS_LEFT);
gtk_scale_set_draw_value(GTK_SCALE(hscale), TRUE);
gtk_range_set_update_policy(GTK_RANGE(hscale),
GTK_UPDATE_DISCONTINUOUS);
gtk_signal_connect_object(GTK_OBJECT(subsong_adj), "value_changed",
GTK_SIGNAL_FUNC(uade_seek_directly),
NULL);
/* previous subsong button, will be used by all styles of the seek popup*/
prev_button = gtk_button_new_with_label("<");
gtk_widget_set_usize(prev_button, 27, -1);
gtk_signal_connect_object(GTK_OBJECT(prev_button), "clicked",
GTK_SIGNAL_FUNC(uade_seek_previous),
NULL);
prev_button_frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(prev_button_frame),
GTK_SHADOW_IN);
/* next subsong button, will be used by all styles of the seek popup*/
next_button = gtk_button_new_with_label(">");
gtk_widget_set_usize(next_button, 27, -1);
gtk_signal_connect_object(GTK_OBJECT(next_button), "clicked",
GTK_SIGNAL_FUNC(uade_seek_next), NULL);
ffwd_button_frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(ffwd_button_frame),
GTK_SHADOW_IN);
ffwd_button = gtk_button_new_with_label("10s fwd");
gtk_widget_set_usize(ffwd_button, 27, -1);
gtk_signal_connect_object(GTK_OBJECT(ffwd_button), "clicked",
GTK_SIGNAL_FUNC(uade_ffwd), NULL);
/* with the alternative styles of the subsongseeker,
* following suggestions made by David Le Corfec*/
seek_button_box = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(seekpopup), seek_button_box);
frame = gtk_frame_new(NULL);
gtk_box_pack_start_defaults(GTK_BOX(seek_button_box), frame);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
seek_button_vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), seek_button_vbox);
gtk_signal_connect(GTK_OBJECT(seek_button_vbox), "focus_out_event",
GTK_SIGNAL_FUNC(focus_out_event), NULL);
prev_next_button_box = gtk_hbox_new(FALSE, 0);
/* use the previous defined buttons here */
gtk_box_pack_start_defaults(GTK_BOX(seek_button_vbox),
prev_button_frame);
gtk_container_add(GTK_CONTAINER(prev_button_frame),
prev_next_button_box);
gtk_box_pack_start_defaults(GTK_BOX(prev_next_button_box),
prev_button);
gtk_box_pack_start_defaults(GTK_BOX(prev_next_button_box),
next_button);
seek_slider_box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(seek_button_vbox), seek_slider_box,
FALSE, FALSE, 0);
/* use the previous defined slider and label here */
gtk_box_pack_start(GTK_BOX(seek_slider_box), hscale, FALSE, FALSE,
0);
gtk_box_pack_start(GTK_BOX(seek_slider_box), maxsong_label, FALSE,
FALSE, 0);
/* use the previous defined buttons here */
gtk_box_pack_start_defaults(GTK_BOX(seek_button_vbox),
ffwd_button_frame);
gtk_container_add(GTK_CONTAINER(ffwd_button_frame),
ffwd_button);
gtk_widget_show_all(seekpopup);
seekpopup_open = 1;
} else {
gdk_window_raise(seekpopup->window);
}
}
GtkWidget *
gu_playdeck_add(gu_window_t *gw, GtkWidget *parent)
{
GtkToolItem *ti;
GtkWidget *w;
GtkWidget *l;
GtkWidget *vbox;
GtkWidget *playdeck;
playdeck_t *pd = calloc(1, sizeof(playdeck_t));
prop_courier_t *pc = gw->gw_gu->gu_pc;
playdeck = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(parent), playdeck, FALSE, TRUE, 0);
w = gtk_hseparator_new();
gtk_widget_show(w);
gtk_box_pack_start(GTK_BOX(playdeck), w, FALSE, TRUE, 0);
pd->root = gtk_hbox_new(FALSE, 1);
gtk_widget_show(pd->root);
gtk_box_pack_start(GTK_BOX(playdeck), pd->root, FALSE, TRUE, 0);
/* Playdeck album art */
w = gtk_image_new();
gtk_widget_show(w);
gtk_misc_set_alignment(GTK_MISC(w), 0, 1);
gtk_box_pack_start(GTK_BOX(pd->root), w, FALSE, TRUE, 0);
pd->sub_album_art =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current",
"metadata", "album_art"),
PROP_TAG_CALLBACK_STRING, pd_set_albumart, w,
PROP_TAG_COURIER, pc,
NULL);
/* Middle vbox */
vbox = gtk_vbox_new(FALSE, 1);
gtk_box_pack_start(GTK_BOX(pd->root), vbox, TRUE, TRUE, 0);
/* Title of current track */
l = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(l), 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), l, TRUE, TRUE, 0);
g_object_set(G_OBJECT(l),
"ellipsize", PANGO_ELLIPSIZE_END, NULL);
pd->sub_title =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current",
"metadata", "title"),
PROP_TAG_CALLBACK_STRING, set_current_title, l,
PROP_TAG_COURIER, pc,
NULL);
/* Title of current track */
pd->trackextra = gtk_label_new("");
g_object_set(G_OBJECT(pd->trackextra),
"ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_misc_set_alignment(GTK_MISC(pd->trackextra), 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), pd->trackextra, TRUE, TRUE, 0);
pd->sub_album =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current",
"metadata", "album"),
PROP_TAG_CALLBACK_STRING, set_current_album, pd,
PROP_TAG_COURIER, pc,
NULL);
pd->sub_artist =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current",
"metadata", "artist"),
PROP_TAG_CALLBACK_STRING, set_current_artist, pd,
PROP_TAG_COURIER, pc,
NULL);
/* The toolbar */
pd->tbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(pd->tbar), GTK_TOOLBAR_ICONS);
gtk_box_pack_start(GTK_BOX(vbox), pd->tbar, FALSE, TRUE, 0);
/* Prev button */
pd->prev = ti = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_PREVIOUS);
gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);
g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(prev_clicked), pd);
pd->sub_canSkipBackward =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current",
"canSkipBackward"),
PROP_TAG_CALLBACK_INT, gu_subscription_set_sensitivity,
pd->prev,
PROP_TAG_COURIER, pc,
NULL);
/* Play / Pause */
pd->playpause = ti = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_PLAY);
gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);
g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(playpause_clicked), pd);
pd->sub_canPause =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current",
"canPause"),
PROP_TAG_CALLBACK_INT, gu_subscription_set_sensitivity,
pd->playpause,
PROP_TAG_COURIER, pc,
NULL);
/* Next button */
pd->next = ti = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_NEXT);
gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);
g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(next_clicked), pd);
pd->sub_canSkipForward =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current",
"canSkipForward"),
PROP_TAG_CALLBACK_INT, gu_subscription_set_sensitivity,
pd->next,
PROP_TAG_COURIER, pc,
NULL);
/* Separator */
ti = gtk_separator_tool_item_new();
gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);
/* Subscribe to playstatus */
pd->sub_playstatus =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current", "playstatus"),
PROP_TAG_CALLBACK, update_playstatus, pd,
PROP_TAG_COURIER, pc,
NULL);
/**
* Media position
*/
pd->pos_adjust = gtk_adjustment_new(0, 0, 0, 0, 0, 0);
pd->pos_slider = gtk_hscale_new(GTK_ADJUSTMENT(pd->pos_adjust));
gtk_scale_set_value_pos (GTK_SCALE(pd->pos_slider), GTK_POS_LEFT);
g_signal_connect(G_OBJECT(pd->pos_slider), "grab-focus",
G_CALLBACK(slider_grabbed), pd);
g_signal_connect(G_OBJECT(pd->pos_slider), "change-value",
G_CALLBACK(slider_updated), pd);
g_signal_connect(G_OBJECT(pd->pos_slider), "format-value",
G_CALLBACK(slider_value_callback), pd);
ti = gtk_tool_item_new();
gtk_tool_item_set_expand(ti, TRUE);
gtk_container_add(GTK_CONTAINER(ti), pd->pos_slider);
gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);
/* Subscribe to current track position */
pd->sub_pos =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current", "currenttime"),
PROP_TAG_CALLBACK_FLOAT, update_curtime, pd,
PROP_TAG_COURIER, pc,
NULL);
/* Subscribe to current track duration */
pd->sub_duration =
prop_subscribe(0,
PROP_TAG_NAME("global", "media", "current",
"metadata", "duration"),
PROP_TAG_CALLBACK_FLOAT, update_duration, pd,
PROP_TAG_COURIER, pc,
NULL);
/* Separator */
ti = gtk_separator_tool_item_new();
gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);
gtk_widget_show_all(vbox);
/**
* Volume control
*/
ti = gtk_tool_item_new();
pd->volume = gtk_volume_button_new();
gtk_container_add(GTK_CONTAINER(ti), pd->volume);
gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);
g_signal_connect(G_OBJECT(pd->volume), "value-changed",
G_CALLBACK(read_mastervol), pd);
pd->sub_volume =
prop_subscribe(0,
PROP_TAG_NAME("global", "audio", "mastervolume"),
PROP_TAG_CALLBACK_FLOAT, update_mastervol, pd,
PROP_TAG_COURIER, pc,
NULL);
gtk_widget_show_all(GTK_WIDGET(ti));
g_signal_connect(playdeck, "destroy", G_CALLBACK(playdeck_dtor), pd);
return playdeck;
}
GtkWidget *
create_editor_window(const char *tag)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *combo;
GtkWidget *separator;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *scale;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
set_window_title(window, tag, "Patch Edit");
g_signal_connect (G_OBJECT(window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (G_OBJECT (window), "delete-event",
G_CALLBACK (on_delete_event_wrapper),
(gpointer)gtk_widget_hide);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
editor_status_label = gtk_label_new (" ");
gtk_container_add (GTK_CONTAINER (vbox), editor_status_label);
gtk_misc_set_alignment (GTK_MISC (editor_status_label), 0, 0.5);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
label = gtk_label_new ("Patch Name");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
editor_name_entry = gtk_entry_new_with_max_length(10);
gtk_box_pack_start (GTK_BOX (hbox), editor_name_entry, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(editor_name_entry), "changed",
G_CALLBACK(patch_edit_on_name_entry_changed), NULL);
/* -FIX- comment (reuse Performance Name?)
* GtkWidget *comment_label = gtk_label_new ("Comment");
* gtk_box_pack_start (GTK_BOX (hbox), comment_label, FALSE, FALSE, 2);
* gtk_misc_set_alignment (GTK_MISC (comment_label), 0, 0.5);
* GtkWidget *comment_entry = gtk_entry_new_with_max_length(60);
* gtk_box_pack_start (GTK_BOX (hbox), comment_entry, TRUE, TRUE, 2);
*/
/* separator */
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 2);
gtk_widget_show_all(vbox);
/* editor widgets */
create_widgy_editor(tag);
gtk_box_pack_start (GTK_BOX (vbox), widgy_widget, TRUE, FALSE, 2);
gtk_widget_show(widgy_widget);
create_retro_editor(tag);
gtk_box_pack_start (GTK_BOX (vbox), retro_widget, TRUE, FALSE, 2);
/* separator */
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 2);
gtk_widget_show(separator);
/* edit action widgets */
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
label = gtk_label_new ("Editor Mode");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
combo = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Widgy");
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Retro");
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(combo), "changed",
G_CALLBACK(patch_edit_on_mode_change), NULL);
/* -FIX- add: [compare to original?] [swap A/B?] [close?] */
label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, FALSE, 0);
editor_discard_button = gtk_button_new_with_label ("Discard Changes");
gtk_box_pack_start (GTK_BOX (hbox), editor_discard_button, FALSE, FALSE, 2);
gtk_signal_connect (GTK_OBJECT (editor_discard_button), "clicked",
GTK_SIGNAL_FUNC (on_editor_discard_button_press),
NULL);
editor_save_button = gtk_button_new_with_label ("Save Changes into Patch Bank");
gtk_box_pack_start (GTK_BOX (hbox), editor_save_button, FALSE, FALSE, 2);
gtk_signal_connect (GTK_OBJECT (editor_save_button), "clicked",
GTK_SIGNAL_FUNC (on_editor_save_button_press),
NULL);
gtk_widget_show_all(hbox);
/* test note widgets */
frame = gtk_frame_new ("Test Note");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
table = gtk_table_new (3, 3, FALSE);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_container_set_border_width (GTK_CONTAINER (table), 2);
gtk_table_set_row_spacings (GTK_TABLE (table), 1);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
label = gtk_label_new ("key");
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
scale = gtk_hscale_new (GTK_ADJUSTMENT (test_note_key_adj));
gtk_table_attach (GTK_TABLE (table), scale, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
label = gtk_label_new ("velocity");
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
scale = gtk_hscale_new (GTK_ADJUSTMENT (test_note_velocity_adj));
gtk_table_attach (GTK_TABLE (table), scale, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
editor_test_note_button = gtk_button_new_with_label (" Send Test Note");
gtk_table_attach (GTK_TABLE (table), editor_test_note_button, 2, 3, 0, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 4, 0);
gtk_button_set_focus_on_click(GTK_BUTTON(editor_test_note_button), FALSE);
g_signal_connect (G_OBJECT (editor_test_note_button), "pressed",
G_CALLBACK (on_test_note_button_press), (gpointer)1);
g_signal_connect (G_OBJECT (editor_test_note_button), "released",
G_CALLBACK (on_test_note_button_press), (gpointer)0);
gtk_widget_show_all (frame);
editor_window = window;
return editor_window;
}
static GtkWidget *
create_sound_note(void)
{
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *button[NELEMENTS(sample_rate)];
GSList *gslist;
int i;
main_vbox = gtk_vbox_new(FALSE, 2);
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 10);
gtk_widget_show(hbox);
frame = gtk_frame_new("Sample rate");
gtk_container_set_border_width(GTK_CONTAINER(frame), 5);
gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, FALSE, 0);
gtk_widget_show(frame);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(frame), vbox);
gtk_widget_show(vbox);
/* Sample rate */
for (gslist = 0, i = 0; i < NELEMENTS(sample_rate); ++i) {
button[i] = gtk_radio_button_new_with_label(gslist,
sample_rate[i].str);
GTK_WIDGET_UNSET_FLAGS(button[i], GTK_CAN_FOCUS);
gslist = gtk_radio_button_group(GTK_RADIO_BUTTON(button[i]));
gtk_box_pack_start(GTK_BOX(vbox), button[i], FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(button[i]), "clicked",
GTK_SIGNAL_FUNC(sample_rate_button_clicked),
(gpointer)sample_rate[i].rate);
gtk_widget_show(button[i]);
}
for (i = 0; i < NELEMENTS(sample_rate); ++i) {
if (sample_rate[i].rate == Config.SampleRate)
break;
}
if (i == NELEMENTS(sample_rate))
i = 0;
gtk_signal_emit_by_name(GTK_OBJECT(button[i]), "clicked");
vbox = gtk_vbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 10);
gtk_widget_show(vbox);
for (i = 0; i < NELEMENTS(sound_right_frame); ++i) {
GtkObject *adjust;
GtkWidget *hscale;
GtkWidget *align;
frame = gtk_frame_new(sound_right_frame[i].name);
gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0);
gtk_widget_show(frame);
align = gtk_alignment_new(0.5, 0.5, 0.9, 0.9);
gtk_container_add(GTK_CONTAINER(frame), align);
gtk_widget_show(align);
adjust = gtk_adjustment_new(sound_right_frame[i].value,
sound_right_frame[i].min, sound_right_frame[i].max,
1.0, 0.0, 0.0);
hscale = gtk_hscale_new(GTK_ADJUSTMENT(adjust));
gtk_scale_set_value_pos(GTK_SCALE(hscale), GTK_POS_RIGHT);
gtk_scale_set_digits(GTK_SCALE(hscale), 0);
gtk_container_add(GTK_CONTAINER(align), hscale);
gtk_signal_connect(GTK_OBJECT(adjust), "value_changed",
GTK_SIGNAL_FUNC(vol_adj_value_changed),(gpointer)i);
gtk_widget_show(hscale);
if (i == 0)
gtk_adjustment_set_value(GTK_ADJUSTMENT(adjust),
Config.BufferSize);
else {
int *p = (int *)(((char *)&Config) + sound_right_frame[i].offset);
gtk_adjustment_set_value(GTK_ADJUSTMENT(adjust), *p);
}
}
button[0] = gtk_check_button_new_with_label("Enable ADPCM LPF");
gtk_container_set_border_width(GTK_CONTAINER(button[0]), 5);
gtk_box_pack_start(GTK_BOX(main_vbox), button[0], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(button[0]), "clicked",
GTK_SIGNAL_FUNC(adpcm_lpf_button_clicked), 0);
gtk_widget_show(button[0]);
if (Config.Sound_LPF)
gtk_signal_emit_by_name(GTK_OBJECT(button[0]), "clicked");
return main_vbox;
}
void lightdash_configure (XfcePanelPlugin *plugin,
LightdashPlugin *lightdash)
{
GtkWidget *dialog;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *opacity_slider;
GtkWidget *show_desktop_button;
GtkWidget *toplevel;
GtkWindow *window;
window = NULL;
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (plugin));
if (gtk_widget_is_toplevel (toplevel))
{
window = GTK_WINDOW (toplevel);
}
xfce_panel_plugin_block_menu (plugin);
dialog = xfce_titled_dialog_new_with_buttons (_("lightdash"),
window,
GTK_DIALOG_DESTROY_WITH_PARENT
#if GTK_CHECK_VERSION (3, 0, 0)
#else
| GTK_DIALOG_NO_SEPARATOR
#endif
,
GTK_STOCK_HELP, GTK_RESPONSE_HELP,
GTK_STOCK_CLOSE, GTK_RESPONSE_OK,
NULL);
#if GTK_CHECK_VERSION (3, 0, 0)
hbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
#else
hbox = gtk_hbox_new (FALSE, 0);
#endif
label = gtk_label_new_with_mnemonic (_("_Title:"));
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), gtk_label_get_text (GTK_LABEL (lightdash->button_label)));
g_signal_connect (G_OBJECT (entry), "changed",
G_CALLBACK (lightdash_preferences_entry_changed), lightdash);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
hbox, TRUE, TRUE, 6);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 6);
gtk_widget_show_all (hbox);
#if GTK_CHECK_VERSION (3, 0, 0)
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#else
hbox = gtk_hbox_new (FALSE, 0);
#endif
opacity_slider = gtk_hscale_new_with_range (0.0, 100.0, 1.0);
gtk_scale_set_value_pos (GTK_SCALE (opacity_slider), GTK_POS_RIGHT);
gtk_widget_set_size_request (GTK_WIDGET (opacity_slider), 200, -1);
gtk_range_set_value (GTK_RANGE (opacity_slider), lightdash->opacity);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
hbox, TRUE, TRUE, 6);
label = gtk_label_new_with_mnemonic (_("Background opacit_y:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox), opacity_slider, TRUE, TRUE, 6);
g_signal_connect (G_OBJECT (opacity_slider), "value-changed",
G_CALLBACK (lightdash_opacity_slider_changed), lightdash);
gtk_widget_show_all (hbox);
show_desktop_button = gtk_check_button_new_with_label (_("Show desktop behind dashboard"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (show_desktop_button), lightdash->show_desktop);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
show_desktop_button, TRUE, TRUE, 6);
g_signal_connect (G_OBJECT (show_desktop_button), "toggled",
G_CALLBACK (lightdash_show_desktop_button_toggled), lightdash);
g_object_set_data (G_OBJECT (plugin), "dialog", dialog);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (lightdash_configure_response), lightdash);
gtk_widget_show_all (dialog);
}
static void
xfburn_preferences_dialog_init (XfburnPreferencesDialog * obj)
{
GtkBox *box = GTK_BOX (GTK_DIALOG (obj)->vbox);
XfburnPreferencesDialogPrivate *priv = XFBURN_PREFERENCES_DIALOG_GET_PRIVATE (obj);
GtkWidget *vbox, *vbox2, *vbox3, *hbox;
GtkWidget *label;
GtkWidget *frame;
GtkWidget *scrolled_window;
GtkListStore *icon_store, *store;
gint x,y;
GdkPixbuf *icon = NULL;
GtkTreeIter iter;
GtkTreeViewColumn *column_name;
GtkCellRenderer *cell_icon, *cell_name;
GtkWidget *button_close;
gint idx;
gtk_window_set_title (GTK_WINDOW (obj), _("Preferences"));
xfce_titled_dialog_set_subtitle (XFCE_TITLED_DIALOG (obj), _("Tune how Xfburn behaves"));
gtk_window_set_default_size (GTK_WINDOW (obj), 775, 400);
gtk_window_set_destroy_with_parent (GTK_WINDOW (obj), TRUE);
gtk_window_set_icon_name (GTK_WINDOW (obj), GTK_STOCK_PREFERENCES);
gtk_dialog_set_has_separator (GTK_DIALOG (obj), FALSE);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (box, hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
g_object_set (G_OBJECT (scrolled_window),
"hscrollbar-policy", GTK_POLICY_NEVER,
"shadow-type", GTK_SHADOW_IN,
"vscrollbar-policy", GTK_POLICY_NEVER,
NULL);
gtk_box_pack_start (GTK_BOX (hbox), scrolled_window, FALSE, FALSE, 0);
gtk_widget_show (scrolled_window);
/* icon bar */
icon_store = gtk_list_store_new (SETTINGS_LIST_N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT);
priv->icon_bar = exo_icon_bar_new_with_model (GTK_TREE_MODEL (icon_store));
exo_icon_bar_set_pixbuf_column (EXO_ICON_BAR (priv->icon_bar), SETTINGS_LIST_PIXBUF_COLUMN);
exo_icon_bar_set_text_column (EXO_ICON_BAR (priv->icon_bar), SETTINGS_LIST_TEXT_COLUMN);
gtk_container_add (GTK_CONTAINER (scrolled_window), priv->icon_bar);
gtk_widget_show (priv->icon_bar);
/* notebook */
priv->notebook = gtk_notebook_new ();
gtk_container_set_border_width (GTK_CONTAINER (priv->notebook), BORDER);
g_object_set (G_OBJECT (priv->notebook),
"show-border", FALSE,
"show-tabs", FALSE,
NULL);
gtk_box_pack_start (GTK_BOX (hbox), priv->notebook, TRUE, TRUE, BORDER);
gtk_widget_show (priv->notebook);
/* general tab */
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), BORDER);
idx = gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), vbox, NULL);
gtk_widget_show (vbox);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
frame = xfce_gtk_frame_box_new_with_content (_("Temporary directory"), vbox2);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, BORDER);
gtk_widget_show (frame);
priv->chooser_button = gtk_file_chooser_button_new (_("Temporary directory"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_box_pack_start (GTK_BOX (vbox2), priv->chooser_button, FALSE, FALSE, BORDER);
gtk_widget_show (priv->chooser_button);
priv->check_clean_tmpdir = gtk_check_button_new_with_mnemonic (_("_Clean temporary directory on exit"));
gtk_box_pack_start (GTK_BOX (vbox2), priv->check_clean_tmpdir, FALSE, FALSE, BORDER);
gtk_widget_show (priv->check_clean_tmpdir);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
frame = xfce_gtk_frame_box_new_with_content (_("File browser"), vbox2);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, BORDER);
gtk_widget_show (frame);
priv->check_show_hidden = gtk_check_button_new_with_mnemonic (_("Show _hidden files"));
gtk_box_pack_start (GTK_BOX (vbox2), priv->check_show_hidden, FALSE, FALSE, BORDER);
gtk_widget_show (priv->check_show_hidden);
g_signal_connect (G_OBJECT (priv->check_show_hidden), "clicked", G_CALLBACK (cb_show_hidden_clicked), NULL);
priv->check_show_human_readable = gtk_check_button_new_with_mnemonic (_("Show human_readable filesizes"));
gtk_box_pack_start (GTK_BOX (vbox2), priv->check_show_human_readable, FALSE, FALSE, BORDER);
gtk_widget_show (priv->check_show_human_readable);
icon = gtk_widget_render_icon (GTK_WIDGET (priv->icon_bar),
GTK_STOCK_PROPERTIES,
GTK_ICON_SIZE_DIALOG,
NULL);
gtk_list_store_append (icon_store, &iter);
gtk_list_store_set (icon_store, &iter,
SETTINGS_LIST_PIXBUF_COLUMN, icon,
SETTINGS_LIST_TEXT_COLUMN, _("General"),
SETTINGS_LIST_INDEX_COLUMN, idx,
-1);
g_object_unref (G_OBJECT (icon));
/* devices tab */
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), BORDER);
idx = gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), vbox, NULL);
gtk_widget_show (vbox);
label = gtk_label_new (_("Devices"));
gtk_widget_show (label);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (priv->notebook),
gtk_notebook_get_nth_page (GTK_NOTEBOOK (priv->notebook), 1), label);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
frame = xfce_gtk_frame_box_new_with_content (_("Detected devices"), vbox2);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, BORDER);
gtk_widget_show (frame);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN);
gtk_widget_show (scrolled_window);
gtk_box_pack_start (GTK_BOX (vbox2), scrolled_window, TRUE, TRUE, BORDER);
store = gtk_list_store_new (DEVICE_LIST_N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN);
priv->treeview_devices = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), DEVICE_LIST_COLUMN_NAME, GTK_SORT_ASCENDING);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (priv->treeview_devices), TRUE);
gtk_widget_show (priv->treeview_devices);
gtk_container_add (GTK_CONTAINER (scrolled_window), priv->treeview_devices);
g_object_unref (store);
/* add columns */
column_name = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column_name, _("Name"));
gtk_tree_view_column_set_expand (column_name, TRUE);
cell_icon = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column_name, cell_icon, FALSE);
gtk_tree_view_column_set_attributes (column_name, cell_icon, "pixbuf", DEVICE_LIST_COLUMN_ICON, NULL);
g_object_set (cell_icon, "xalign", 0.0, "ypad", 0, NULL);
cell_name = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column_name, cell_name, TRUE);
gtk_tree_view_column_set_attributes (column_name, cell_name, "text", DEVICE_LIST_COLUMN_NAME, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview_devices), column_name);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview_devices), -1, _("Node"),
gtk_cell_renderer_text_new (), "text", DEVICE_LIST_COLUMN_NODE, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview_devices), -1, _("Write CD-R"),
gtk_cell_renderer_toggle_new (), "active", DEVICE_LIST_COLUMN_CDR, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview_devices), -1, _("Write CD-RW"),
gtk_cell_renderer_toggle_new (), "active", DEVICE_LIST_COLUMN_CDRW,
NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview_devices), -1, _("Write DVD-R"),
gtk_cell_renderer_toggle_new (), "active", DEVICE_LIST_COLUMN_DVDR,
NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview_devices), -1, _("Write DVD-RAM"),
gtk_cell_renderer_toggle_new (), "active", DEVICE_LIST_COLUMN_DVDRAM,
NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview_devices), -1, _("Write Blu-ray"),
gtk_cell_renderer_toggle_new (), "active", DEVICE_LIST_COLUMN_BD,
NULL);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, BORDER);
gtk_widget_show (hbox);
priv->button_scan = xfce_gtk_button_new_mixed (GTK_STOCK_CDROM, _("Sc_an for devices"));
gtk_box_pack_end (GTK_BOX (hbox), priv->button_scan, FALSE, FALSE, BORDER);
g_signal_connect (G_OBJECT (priv->button_scan), "clicked", G_CALLBACK (scan_button_clicked_cb), obj);
gtk_widget_show (priv->button_scan);
gtk_icon_size_lookup (GTK_ICON_SIZE_DIALOG, &x, &y);
icon = gtk_icon_theme_load_icon ( gtk_icon_theme_get_default(), "media-optical", x, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
if (!icon)
icon = gtk_icon_theme_load_icon ( gtk_icon_theme_get_default(), "media-cdrom", x, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
if (!icon)
icon = gtk_icon_theme_load_icon ( gtk_icon_theme_get_default(), GTK_STOCK_CDROM, x, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
gtk_list_store_append (icon_store, &iter);
gtk_list_store_set (icon_store, &iter,
SETTINGS_LIST_PIXBUF_COLUMN, icon,
SETTINGS_LIST_TEXT_COLUMN, _("Devices"),
SETTINGS_LIST_INDEX_COLUMN, idx,
-1);
if (icon)
g_object_unref (G_OBJECT (icon));
exo_mutual_binding_new (G_OBJECT (priv->notebook), "page", G_OBJECT (priv->icon_bar), "active");
/* below the device list */
#if 0
priv->check_empty_speed_list = gtk_check_button_new_with_mnemonic (_("Show warning on _empty speed list"));
gtk_box_pack_start (GTK_BOX (vbox2), priv->check_empty_speed_list, FALSE, FALSE, BORDER);
gtk_widget_show (priv->check_empty_speed_list);
#endif
/* fifo */
vbox3 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox3);
frame = xfce_gtk_frame_box_new_with_content (_("FIFO buffer size (in kb)"), vbox3);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, BORDER);
gtk_widget_show (frame);
priv->scale_fifo = gtk_hscale_new_with_range (0.0, FIFO_MAX_SIZE, 32.0);
gtk_scale_set_value_pos (GTK_SCALE (priv->scale_fifo), GTK_POS_LEFT);
gtk_range_set_value (GTK_RANGE (priv->scale_fifo), 0);
gtk_box_pack_start (GTK_BOX (vbox3), priv->scale_fifo, FALSE, FALSE, BORDER/2);
gtk_widget_show (priv->scale_fifo);
/* action buttons */
button_close = gtk_button_new_from_stock ("gtk-close");
gtk_widget_show (button_close);
gtk_dialog_add_action_widget (GTK_DIALOG (obj), button_close, GTK_RESPONSE_CLOSE);
GTK_WIDGET_SET_FLAGS (button_close, GTK_CAN_DEFAULT);
gtk_widget_grab_focus (button_close);
gtk_widget_grab_default (button_close);
g_signal_connect (G_OBJECT (obj), "response", G_CALLBACK (xfburn_preferences_dialog_response_cb), priv);
refresh_devices_list (obj);
g_object_unref (icon_store);
}
GtkWidget*
create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *frame1;
GtkWidget *table2;
GtkWidget *label4;
GtkWidget *label5;
GtkWidget *hscaleBrightness;
GtkWidget *hscaleSaturation;
GtkWidget *hscaleContrast;
GtkWidget *label3;
GtkWidget *label1;
GtkWidget *frame2;
GtkWidget *table3;
GtkWidget *label6;
GtkWidget *hscaleGamma;
GtkWidget *hscaleGammaR;
GtkWidget *label8;
GtkWidget *hscaleGammaG;
GtkWidget *label9;
GtkWidget *label10;
GtkWidget *label7;
GtkWidget *hscaleGammaB;
GtkWidget *hscaleGammaWeight;
GtkWidget *label2;
GtkWidget *hscale1;
GtkWidget *drawingarea1;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_container_set_border_width (GTK_CONTAINER (dialog1), 6);
gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("MPlayer eq2"));
gtk_window_set_resizable (GTK_WINDOW (dialog1), FALSE);
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (hbox1), frame1, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_NONE);
table2 = gtk_table_new (3, 2, FALSE);
gtk_widget_show (table2);
gtk_container_add (GTK_CONTAINER (frame1), table2);
gtk_container_set_border_width (GTK_CONTAINER (table2), 12);
gtk_table_set_row_spacings (GTK_TABLE (table2), 6);
gtk_table_set_col_spacings (GTK_TABLE (table2), 12);
label4 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Brigh_tness:"));
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table2), label4, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
label5 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Saturation:"));
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table2), label5, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
hscaleBrightness = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, -1, 1, 0.05, 1, 0)));
gtk_widget_show (hscaleBrightness);
gtk_table_attach (GTK_TABLE (table2), hscaleBrightness, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleBrightness, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleBrightness), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleBrightness), 2);
hscaleSaturation = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 3, 0.05, 1, 0)));
gtk_widget_show (hscaleSaturation);
gtk_table_attach (GTK_TABLE (table2), hscaleSaturation, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleSaturation, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleSaturation), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleSaturation), 2);
hscaleContrast = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, -2, 2, 0.05, 1, 0)));
gtk_widget_show (hscaleContrast);
gtk_table_attach (GTK_TABLE (table2), hscaleContrast, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleContrast, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleContrast), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleContrast), 2);
label3 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Contrast:"));
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table2), label3, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
label1 = gtk_label_new ("");
gtk_widget_show (label1);
gtk_frame_set_label_widget (GTK_FRAME (frame1), label1);
gtk_label_set_use_markup (GTK_LABEL (label1), TRUE);
gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT);
frame2 = gtk_frame_new (NULL);
gtk_widget_show (frame2);
gtk_box_pack_start (GTK_BOX (hbox1), frame2, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_NONE);
table3 = gtk_table_new (5, 2, FALSE);
gtk_widget_show (table3);
gtk_container_add (GTK_CONTAINER (frame2), table3);
gtk_container_set_border_width (GTK_CONTAINER (table3), 12);
gtk_table_set_row_spacings (GTK_TABLE (table3), 6);
gtk_table_set_col_spacings (GTK_TABLE (table3), 12);
label6 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Initial:"));
gtk_widget_show (label6);
gtk_table_attach (GTK_TABLE (table3), label6, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5);
hscaleGamma = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0)));
gtk_widget_show (hscaleGamma);
gtk_table_attach (GTK_TABLE (table3), hscaleGamma, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleGamma, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleGamma), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleGamma), 2);
hscaleGammaR = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0)));
gtk_widget_show (hscaleGammaR);
gtk_table_attach (GTK_TABLE (table3), hscaleGammaR, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleGammaR, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaR), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleGammaR), 2);
label8 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Red:"));
gtk_widget_show (label8);
gtk_table_attach (GTK_TABLE (table3), label8, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label8), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5);
hscaleGammaG = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0)));
gtk_widget_show (hscaleGammaG);
gtk_table_attach (GTK_TABLE (table3), hscaleGammaG, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleGammaG, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaG), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleGammaG), 2);
label9 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Green:"));
gtk_widget_show (label9);
gtk_table_attach (GTK_TABLE (table3), label9, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label9), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5);
label10 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Blue:"));
gtk_widget_show (label10);
gtk_table_attach (GTK_TABLE (table3), label10, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label10), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label10), 0, 0.5);
label7 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Weight:"));
gtk_widget_show (label7);
gtk_table_attach (GTK_TABLE (table3), label7, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5);
hscaleGammaB = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0)));
gtk_widget_show (hscaleGammaB);
gtk_table_attach (GTK_TABLE (table3), hscaleGammaB, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleGammaB, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaB), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleGammaB), 2);
hscaleGammaWeight = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 1, 0.05, 1, 0)));
gtk_widget_show (hscaleGammaWeight);
gtk_table_attach (GTK_TABLE (table3), hscaleGammaWeight, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleGammaWeight, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaWeight), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleGammaWeight), 2);
label2 = gtk_label_new (QT_TR_NOOP("<b>Gamma</b>"));
gtk_widget_show (label2);
gtk_frame_set_label_widget (GTK_FRAME (frame2), label2);
gtk_label_set_use_markup (GTK_LABEL (label2), TRUE);
gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 1, 1, 0)));
gtk_widget_show (hscale1);
gtk_box_pack_start (GTK_BOX (vbox1), hscale1, FALSE, FALSE, 0);
drawingarea1 = gtk_drawing_area_new ();
gtk_widget_show (drawingarea1);
gtk_box_pack_start (GTK_BOX (vbox1), drawingarea1, TRUE, TRUE, 0);
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
gtk_label_set_mnemonic_widget (GTK_LABEL (label4), hscaleBrightness);
gtk_label_set_mnemonic_widget (GTK_LABEL (label5), hscaleSaturation);
gtk_label_set_mnemonic_widget (GTK_LABEL (label3), hscaleContrast);
gtk_label_set_mnemonic_widget (GTK_LABEL (label6), hscaleGamma);
gtk_label_set_mnemonic_widget (GTK_LABEL (label8), hscaleGammaR);
gtk_label_set_mnemonic_widget (GTK_LABEL (label9), hscaleGammaG);
gtk_label_set_mnemonic_widget (GTK_LABEL (label10), hscaleGammaB);
gtk_label_set_mnemonic_widget (GTK_LABEL (label7), hscaleGammaWeight);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (dialog1, frame1, "frame1");
GLADE_HOOKUP_OBJECT (dialog1, table2, "table2");
GLADE_HOOKUP_OBJECT (dialog1, label4, "label4");
GLADE_HOOKUP_OBJECT (dialog1, label5, "label5");
GLADE_HOOKUP_OBJECT (dialog1, hscaleBrightness, "hscaleBrightness");
GLADE_HOOKUP_OBJECT (dialog1, hscaleSaturation, "hscaleSaturation");
GLADE_HOOKUP_OBJECT (dialog1, hscaleContrast, "hscaleContrast");
GLADE_HOOKUP_OBJECT (dialog1, label3, "label3");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, frame2, "frame2");
GLADE_HOOKUP_OBJECT (dialog1, table3, "table3");
GLADE_HOOKUP_OBJECT (dialog1, label6, "label6");
GLADE_HOOKUP_OBJECT (dialog1, hscaleGamma, "hscaleGamma");
GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaR, "hscaleGammaR");
GLADE_HOOKUP_OBJECT (dialog1, label8, "label8");
GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaG, "hscaleGammaG");
GLADE_HOOKUP_OBJECT (dialog1, label9, "label9");
GLADE_HOOKUP_OBJECT (dialog1, label10, "label10");
GLADE_HOOKUP_OBJECT (dialog1, label7, "label7");
GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaB, "hscaleGammaB");
GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaWeight, "hscaleGammaWeight");
GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1");
GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
GtkWidget *
_more_page (X264_Gui_Config *config)
{
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *table;
GtkWidget *label;
GtkRequisition size;
GtkRequisition size2;
GtkRequisition size3;
GtkRequisition size4;
GtkRequisition size5;
label = gtk_entry_new_with_max_length (3);
gtk_widget_size_request (label, &size);
gtk_widget_destroy (GTK_WIDGET (label));
label = gtk_check_button_new_with_label ("Deblocking Filter");
gtk_widget_size_request (label, &size2);
gtk_widget_destroy (GTK_WIDGET (label));
label = gtk_label_new ("Partition decision");
gtk_widget_size_request (label, &size3);
gtk_widget_destroy (GTK_WIDGET (label));
label = gtk_label_new ("Threshold");
gtk_widget_size_request (label, &size5);
gtk_widget_destroy (GTK_WIDGET (label));
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
/* Motion Estimation */
frame = gtk_frame_new ("Motion Estimation");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 6);
gtk_widget_show (frame);
table = gtk_table_new (4, 3, TRUE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_container_set_border_width (GTK_CONTAINER (table), 6);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
label = gtk_label_new ("Partition decision");
gtk_widget_set_size_request (label, size2.width, size3.height);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label,
0, 2, 0, 1);
gtk_widget_show (label);
config->more.motion_estimation.partition_decision = gtk_combo_box_new_text ();
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.motion_estimation.partition_decision),
"1 (Fastest)");
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.motion_estimation.partition_decision),
"2");
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.motion_estimation.partition_decision),
"3");
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.motion_estimation.partition_decision),
"4");
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.motion_estimation.partition_decision),
"5 (High quality)");
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.motion_estimation.partition_decision),
"6 (RDO)");
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.motion_estimation.partition_decision),
"6b (RDO on B frames)");
gtk_table_attach_defaults (GTK_TABLE (table), config->more.motion_estimation.partition_decision,
1, 3, 0, 1);
gtk_widget_show (config->more.motion_estimation.partition_decision);
label = gtk_label_new ("Method");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label,
0, 2, 1, 2);
gtk_widget_show (label);
config->more.motion_estimation.method = gtk_combo_box_new_text ();
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.motion_estimation.method),
"Diamond Search");
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.motion_estimation.method),
"Hexagonal Search");
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.motion_estimation.method),
"Uneven Multi-Hexagon");
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.motion_estimation.method),
"Exhaustive search");
gtk_table_attach_defaults (GTK_TABLE (table), config->more.motion_estimation.method,
1, 3, 1, 2);
gtk_widget_show (config->more.motion_estimation.method);
label = gtk_label_new ("Range");
gtk_widget_size_request (label, &size4);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label,
0, 1, 2, 3);
gtk_widget_show (label);
config->more.motion_estimation.range = gtk_entry_new_with_max_length (3);
gtk_widget_set_size_request (config->more.motion_estimation.range,
20, size.height);
gtk_table_attach_defaults (GTK_TABLE (table), config->more.motion_estimation.range,
1, 2, 2, 3);
gtk_widget_show (config->more.motion_estimation.range);
config->more.motion_estimation.chroma_me = gtk_check_button_new_with_label ("Chroma ME");
gtk_table_attach_defaults (GTK_TABLE (table), config->more.motion_estimation.chroma_me,
2, 3, 2, 3);
gtk_widget_show (config->more.motion_estimation.chroma_me);
label = gtk_label_new ("Max Ref. frames");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label,
0, 1, 3, 4);
gtk_widget_show (label);
config->more.motion_estimation.max_ref_frames = gtk_entry_new_with_max_length (3);
gtk_widget_set_size_request (config->more.motion_estimation.max_ref_frames,
20, size.height);
gtk_table_attach_defaults (GTK_TABLE (table), config->more.motion_estimation.max_ref_frames,
1, 2, 3, 4);
gtk_widget_show (config->more.motion_estimation.max_ref_frames);
config->more.motion_estimation.mixed_refs = gtk_check_button_new_with_label ("Mixed Refs");
gtk_table_attach_defaults (GTK_TABLE (table), config->more.motion_estimation.mixed_refs,
2, 3, 3, 4);
gtk_widget_show (config->more.motion_estimation.mixed_refs);
/* Misc. Options */
frame = gtk_frame_new ("Misc. Options");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 6);
gtk_widget_show (frame);
table = gtk_table_new (5, 4, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_container_set_border_width (GTK_CONTAINER (table), 6);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
label = gtk_label_new ("Sample AR");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label,
0, 1, 0, 1);
gtk_widget_show (label);
hbox = gtk_hbox_new (TRUE, 6);
gtk_table_attach_defaults (GTK_TABLE (table), hbox,
1, 2, 0, 1);
gtk_widget_show (hbox);
config->more.misc.sample_ar_x = gtk_entry_new_with_max_length (3);
gtk_widget_set_size_request (config->more.misc.sample_ar_x, 25, size.height);
gtk_box_pack_start (GTK_BOX (hbox), config->more.misc.sample_ar_x, FALSE, TRUE, 0);
gtk_widget_show (config->more.misc.sample_ar_x);
config->more.misc.sample_ar_y = gtk_entry_new_with_max_length (3);
gtk_widget_set_size_request (config->more.misc.sample_ar_y, 25, size.height);
gtk_box_pack_start (GTK_BOX (hbox), config->more.misc.sample_ar_y, FALSE, TRUE, 0);
gtk_widget_show (config->more.misc.sample_ar_y);
label = gtk_label_new ("Threads");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label,
2, 3, 0, 1);
gtk_widget_show (label);
config->more.misc.threads = gtk_entry_new_with_max_length (3);
gtk_widget_set_size_request (config->more.misc.threads, size5.width, size.height);
gtk_table_attach_defaults (GTK_TABLE (table),
config->more.misc.threads,
3, 4, 0, 1);
gtk_widget_show (config->more.misc.threads);
config->more.misc.cabac = gtk_check_button_new_with_label ("CABAC");
gtk_widget_set_size_request (config->more.misc.cabac, size5.width, size.height);
g_signal_connect (G_OBJECT (config->more.misc.cabac),
"toggled",
G_CALLBACK (_more_cabac), config);
gtk_table_attach_defaults (GTK_TABLE (table), config->more.misc.cabac,
0, 1, 1, 2);
gtk_widget_show (config->more.misc.cabac);
label = gtk_label_new ("Trellis");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label,
1, 2, 1, 2);
gtk_widget_show (label);
config->more.misc.trellis = gtk_combo_box_new_text ();
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.misc.trellis),
"Disabled");
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.misc.trellis),
"Enabled (once)");
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.misc.trellis),
"Enabled (mode decision)");
gtk_table_attach_defaults (GTK_TABLE (table), config->more.misc.trellis,
2, 4, 1, 2);
gtk_widget_show (config->more.misc.trellis);
label = gtk_label_new ("Noise reduction");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label,
0, 1, 2, 3);
gtk_widget_show (label);
config->more.misc.noise_reduction = gtk_entry_new_with_max_length (3);
gtk_widget_set_size_request (config->more.misc.noise_reduction, size5.width, size.height);
gtk_table_attach_defaults (GTK_TABLE (table), config->more.misc.noise_reduction,
1, 2, 2, 3);
gtk_widget_show (config->more.misc.noise_reduction);
config->more.misc.df.deblocking_filter = gtk_check_button_new_with_label ("Deblocking Filter");
g_signal_connect (G_OBJECT (config->more.misc.df.deblocking_filter),
"toggled",
G_CALLBACK (_more_deblocking_filter), config);
gtk_table_attach_defaults (GTK_TABLE (table), config->more.misc.df.deblocking_filter,
0, 1, 3, 4);
gtk_widget_show (config->more.misc.df.deblocking_filter);
label = gtk_label_new ("Strength");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_set_size_request (label, size5.width, size4.height);
gtk_table_attach_defaults (GTK_TABLE (table), label,
1, 2, 3, 4);
gtk_widget_show (label);
config->more.misc.df.strength = gtk_hscale_new_with_range (-6.0, 6.0, 1.0);
gtk_widget_size_request (config->more.misc.df.strength, &size4);
gtk_scale_set_digits (GTK_SCALE (config->more.misc.df.strength), 0);
gtk_scale_set_value_pos (GTK_SCALE (config->more.misc.df.strength), GTK_POS_RIGHT);
// gtk_widget_set_size_request (config->more.misc.df.strength, size5.width, size4.height);
gtk_table_attach_defaults (GTK_TABLE (table), config->more.misc.df.strength,
2, 4, 3, 4);
gtk_widget_show (config->more.misc.df.strength);
label = gtk_label_new ("Threshold");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_set_size_request (label, size5.width, size4.height);
gtk_table_attach_defaults (GTK_TABLE (table), label,
1, 2, 4, 5);
gtk_widget_show (label);
config->more.misc.df.threshold = gtk_hscale_new_with_range (-6.0, 6.0, 1.0);
gtk_scale_set_digits (GTK_SCALE (config->more.misc.df.threshold), 0);
gtk_scale_set_value_pos (GTK_SCALE (config->more.misc.df.threshold), GTK_POS_RIGHT);
gtk_table_attach_defaults (GTK_TABLE (table), config->more.misc.df.threshold,
2, 4, 4, 5);
gtk_widget_show (config->more.misc.df.threshold);
/* Debug */
frame = gtk_frame_new ("Debug");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 6);
gtk_widget_show (frame);
table = gtk_table_new (2, 2, TRUE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_container_set_border_width (GTK_CONTAINER (table), 6);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
label = gtk_label_new ("Log level");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_set_size_request (label, size2.width, size3.height);
gtk_table_attach_defaults (GTK_TABLE (table), label,
0, 1, 0, 1);
gtk_widget_show (label);
config->more.debug.log_level = gtk_combo_box_new_text ();
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.debug.log_level),
"None");
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.debug.log_level),
"Error");
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.debug.log_level),
"Warning");
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.debug.log_level),
"Info");
gtk_combo_box_append_text (GTK_COMBO_BOX (config->more.debug.log_level),
"Debug");
gtk_table_attach_defaults (GTK_TABLE (table), config->more.debug.log_level,
1, 2, 0, 1);
gtk_widget_show (config->more.debug.log_level);
label = gtk_label_new ("FourCC");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label,
0, 1, 1, 2);
gtk_widget_show (label);
config->more.debug.fourcc = gtk_entry_new_with_max_length (4);
gtk_table_attach_defaults (GTK_TABLE (table),
config->more.debug.fourcc,
1, 2, 1, 2);
gtk_widget_show (config->more.debug.fourcc);
return vbox;
}