GtkWidget *cd_screenshot_build_options_widget (void)
{
GtkWidget *pHBox;
const gchar *cTooltip;
GtkWidget *pBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, CAIRO_DOCK_GUI_MARGIN);
cTooltip = D_("in seconds.");
pHBox = _add_label_in_new_hbox (D_("Delay"), cTooltip, pBox);
GtkWidget *pScale;
GtkAdjustment *pAdjustment = gtk_adjustment_new (0,
0, // min
10, // max
1, // step
1, // step
0);
pScale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (pAdjustment));
gtk_scale_set_digits (GTK_SCALE (pScale), 0);
g_object_set (pScale, "width-request", 100, NULL);
gldi_dialog_set_widget_text_color (pScale);
gtk_box_pack_end (GTK_BOX (pHBox), pScale, FALSE, FALSE, _MARGIN);
g_object_set_data (G_OBJECT (pBox), "delay", pScale);
gtk_widget_set_tooltip_text (pScale, cTooltip);
cTooltip = D_("Grab the current window instead of the all screen");
pHBox = _add_label_in_new_hbox (D_("Grab the current window"), cTooltip, pBox);
GtkWidget *pCheckButton = gtk_check_button_new ();
gtk_box_pack_end (GTK_BOX (pHBox), pCheckButton, FALSE, FALSE, _MARGIN);
g_object_set_data (G_OBJECT (pBox), "current", pCheckButton);
gtk_widget_set_tooltip_text (pCheckButton, cTooltip);
cTooltip = D_("Let empty to use the default one.");
pHBox = _add_label_in_new_hbox (D_("File name"), cTooltip, pBox);
GtkWidget *pEntry = gtk_entry_new ();
gtk_box_pack_end (GTK_BOX (pHBox), pEntry, FALSE, FALSE, _MARGIN);
g_object_set_data (G_OBJECT (pBox), "name", pEntry);
gtk_widget_set_tooltip_text (pEntry, cTooltip);
cTooltip = D_("Let empty to use the default one.");
pHBox = _add_label_in_new_hbox (D_("Directory"), cTooltip, pBox);
pEntry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (pEntry), myConfig.cDirPath ? myConfig.cDirPath : g_getenv ("HOME"));
g_object_set_data (G_OBJECT (pBox), "dir", pEntry);
GtkWidget *pButtonFileChooser = gtk_button_new_from_icon_name (GLDI_ICON_NAME_OPEN, GTK_ICON_SIZE_BUTTON);
g_signal_connect (G_OBJECT (pButtonFileChooser),
"clicked",
G_CALLBACK (_cairo_dock_pick_a_file),
pEntry);
gtk_box_pack_end (GTK_BOX (pHBox), pButtonFileChooser, FALSE, FALSE, _MARGIN);
gtk_box_pack_end (GTK_BOX (pHBox), pEntry, FALSE, FALSE, _MARGIN);
gtk_widget_set_tooltip_text (pEntry, cTooltip);
return pBox;
}
static void configure(void)
{
GtkWidget *hbox, *label, *scale, *button, *bbox;
GtkAdjustment * adjustment;
if (conf_dialog != NULL)
return;
conf_dialog = gtk_dialog_new();
g_signal_connect (conf_dialog, "destroy", (GCallback)
gtk_widget_destroyed, & conf_dialog);
gtk_window_set_title(GTK_WINDOW(conf_dialog), _("Configure Crystalizer"));
label = gtk_label_new(_("Effect intensity:"));
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area
((GtkDialog *) conf_dialog), label, TRUE, TRUE, 0);
gtk_widget_show(label);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area
((GtkDialog *) conf_dialog), hbox, TRUE, TRUE, 10);
gtk_widget_show(hbox);
adjustment = (GtkAdjustment *) gtk_adjustment_new (value, 0, 15 + 1,
0.1, 1, 1);
scale = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(adjustment));
gtk_box_pack_start(GTK_BOX(hbox), scale, TRUE, TRUE, 10);
gtk_widget_show(scale);
bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_action_area ((GtkDialog *)
conf_dialog), bbox, TRUE, TRUE, 0);
button = gtk_button_new_with_label(_("Ok"));
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked", (GCallback) conf_ok_cb, adjustment);
gtk_widget_grab_default(button);
gtk_widget_show(button);
button = gtk_button_new_with_label(_("Cancel"));
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked", (GCallback) conf_cancel_cb, NULL);
gtk_widget_show(button);
button = gtk_button_new_with_label(_("Apply"));
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked", (GCallback) conf_apply_cb,
adjustment);
gtk_widget_show(button);
gtk_widget_show(bbox);
gtk_widget_show(conf_dialog);
}
static void
gimp_rotate_tool_dialog (GimpTransformTool *tr_tool)
{
GimpRotateTool *rotate = GIMP_ROTATE_TOOL (tr_tool);
GtkWidget *table;
GtkWidget *button;
GtkWidget *scale;
GtkAdjustment *adj;
table = gtk_table_new (4, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacing (GTK_TABLE (table), 1, 6);
gtk_box_pack_start (GTK_BOX (gimp_tool_gui_get_vbox (tr_tool->gui)), table,
FALSE, FALSE, 0);
gtk_widget_show (table);
rotate->angle_adj = (GtkAdjustment *)
gtk_adjustment_new (0, -180, 180, 0.1, 15, 0);
button = gtk_spin_button_new (rotate->angle_adj, 1.0, 2);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (button), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (button), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (button), SB_WIDTH);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_Angle:"),
0.0, 0.5, button, 1, TRUE);
rotate->angle_spin_button = button;
g_signal_connect (rotate->angle_adj, "value-changed",
G_CALLBACK (rotate_angle_changed),
tr_tool);
scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, rotate->angle_adj);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_table_attach (GTK_TABLE (table), scale, 1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 0);
gtk_widget_show (scale);
adj = (GtkAdjustment *) gtk_adjustment_new (0, -1, 1, 1, 10, 0);
button = gtk_spin_button_new (adj, 1.0, 2);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (button), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (button), SB_WIDTH);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 2, _("Center _X:"),
0.0, 0.5, button, 1, TRUE);
rotate->sizeentry = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a",
TRUE, TRUE, FALSE, SB_WIDTH,
GIMP_SIZE_ENTRY_UPDATE_SIZE);
gimp_size_entry_add_field (GIMP_SIZE_ENTRY (rotate->sizeentry),
GTK_SPIN_BUTTON (button), NULL);
gimp_size_entry_set_pixel_digits (GIMP_SIZE_ENTRY (rotate->sizeentry), 2);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 3, _("Center _Y:"),
0.0, 0.5, rotate->sizeentry, 1, TRUE);
g_signal_connect (rotate->sizeentry, "value-changed",
G_CALLBACK (rotate_center_changed),
tr_tool);
}
void FullscreenVideoControllerGtk::createHud()
{
m_hudWindow = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_gravity(GTK_WINDOW(m_hudWindow), GDK_GRAVITY_SOUTH_WEST);
gtk_window_set_type_hint(GTK_WINDOW(m_hudWindow), GDK_WINDOW_TYPE_HINT_NORMAL);
m_hudMotionNotifySignalId = g_signal_connect(m_hudWindow, "motion-notify-event", G_CALLBACK(onFullscreenGtkMotionNotifyEvent), this);
#ifdef GTK_API_VERSION_2
GtkWidget* hbox = gtk_hbox_new(FALSE, 4);
#else
GtkWidget* hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#endif
gtk_container_add(GTK_CONTAINER(m_hudWindow), hbox);
m_playPauseAction = gtk_action_new("play", _("Play / Pause"), _("Play or pause the media"), PAUSE_ICON_NAME);
m_playActionActivateSignalId = g_signal_connect(m_playPauseAction, "activate", G_CALLBACK(togglePlayPauseActivated), this);
GtkWidget* item = gtk_action_create_tool_item(m_playPauseAction);
gtk_box_pack_start(GTK_BOX(hbox), item, FALSE, TRUE, 0);
GtkWidget* label = gtk_label_new(_("Time:"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
GtkAdjustment* adjustment = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 100.0, 0.1, 1.0, 1.0));
#ifdef GTK_API_VERSION_2
m_timeHScale = gtk_hscale_new(adjustment);
#else
m_timeHScale = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, adjustment);
#endif
gtk_scale_set_draw_value(GTK_SCALE(m_timeHScale), FALSE);
gtk_range_set_show_fill_level(GTK_RANGE(m_timeHScale), TRUE);
m_timeScaleButtonPressedSignalId = g_signal_connect(m_timeHScale, "button-press-event", G_CALLBACK(timeScaleButtonPressed), this);
m_timeScaleButtonReleasedSignalId = g_signal_connect(m_timeHScale, "button-release-event", G_CALLBACK(timeScaleButtonReleased), this);
m_hscaleUpdateId = g_signal_connect(m_timeHScale, "value-changed", G_CALLBACK(timeScaleValueChanged), this);
gtk_box_pack_start(GTK_BOX(hbox), m_timeHScale, TRUE, TRUE, 0);
m_timeLabel = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(hbox), m_timeLabel, FALSE, TRUE, 0);
// Volume button.
m_volumeButton = gtk_volume_button_new();
gtk_box_pack_start(GTK_BOX(hbox), m_volumeButton, FALSE, TRUE, 0);
gtk_scale_button_set_value(GTK_SCALE_BUTTON(m_volumeButton), m_player->volume());
m_volumeUpdateId = g_signal_connect(m_volumeButton, "value-changed", G_CALLBACK(volumeValueChanged), this);
m_exitFullscreenAction = gtk_action_new("exit", _("Exit Fullscreen"), _("Exit from fullscreen mode"), EXIT_FULLSCREEN_ICON_NAME);
m_exitFullcreenActionActivateSignalId = g_signal_connect(m_exitFullscreenAction, "activate", G_CALLBACK(exitFullscreenActivated), this);
g_object_set(m_exitFullscreenAction, "icon-name", EXIT_FULLSCREEN_ICON_NAME, NULL);
item = gtk_action_create_tool_item(m_exitFullscreenAction);
gtk_box_pack_start(GTK_BOX(hbox), item, FALSE, TRUE, 0);
m_progressBarUpdateId = g_timeout_add(PROGRESS_BAR_UPDATE_INTERVAL, reinterpret_cast<GSourceFunc>(progressBarUpdateCallback), this);
playStateChanged();
}
static GtkWidget *
create_axis_slider (GtkGears *gears,
int axis)
{
GtkWidget *box, *label, *slider;
GtkAdjustment *adj;
const char *text;
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE);
switch (axis)
{
case GTK_GEARS_X_AXIS:
text = "X";
break;
case GTK_GEARS_Y_AXIS:
text = "Y";
break;
case GTK_GEARS_Z_AXIS:
text = "Z";
break;
default:
g_assert_not_reached ();
}
label = gtk_label_new (text);
gtk_container_add (GTK_CONTAINER (box), label);
gtk_widget_show (label);
adj = gtk_adjustment_new (gtk_gears_get_axis (gears, axis), 0.0, 360.0, 1.0, 12.0, 0.0);
g_object_set_data (G_OBJECT (adj), "axis", GINT_TO_POINTER (axis));
g_signal_connect (adj, "value-changed",
G_CALLBACK (on_axis_value_change),
gears);
slider = gtk_scale_new (GTK_ORIENTATION_VERTICAL, adj);
gtk_scale_set_draw_value (GTK_SCALE (slider), FALSE);
gtk_container_add (GTK_CONTAINER (box), slider);
gtk_widget_set_vexpand (slider, TRUE);
gtk_widget_show (slider);
gtk_widget_show (box);
return box;
}
void setup_ui(int *argc, char ***argv)
{
GtkWidget *window;
GtkGrid *box;
GtkButton *commit;
int i;
gtk_init(argc, argv);
window = GTK_WIDGET(gtk_window_new(GTK_WINDOW_TOPLEVEL));
box = GTK_GRID(gtk_grid_new());
gtk_container_set_border_width(GTK_CONTAINER(window), 12);
gtk_grid_set_column_spacing(box, 12);
gtk_grid_set_row_spacing(box, 6);
for (i = 0; i < nProps; i++) {
GtkRange *scale;
GtkWidget *label;
label = gtk_label_new(props[i].name);
gtk_widget_set_halign(label, GTK_ALIGN_END);
gtk_grid_attach(box, label, 0, i, 1, 1);
scale = GTK_RANGE(gtk_scale_new(GTK_ORIENTATION_HORIZONTAL,
gtk_adjustment_new(props[i].default_value, props[i].min, props[i].max, 0.001, 0.001, 0.001)));
g_signal_connect(scale, "value-changed", G_CALLBACK(update_reverb), NULL);
gtk_widget_set_size_request(GTK_WIDGET(scale), 200, -1);
gtk_grid_attach(box, GTK_WIDGET(scale), 1, i, 1, 1);
label = gtk_label_new(props[i].desc);
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(box, label, 2, i, 1, 1);
props[i].value = scale;
}
commit = GTK_BUTTON(gtk_button_new_with_label("Commit Reverb Settings"));
g_signal_connect(commit, "clicked", G_CALLBACK(update_reverb), NULL);
gtk_grid_attach(box, GTK_WIDGET(commit), 0, nProps, 3, 1);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(box));
gtk_widget_show_all(window);
}
static GtkWidget *
create_axis_slider (int axis)
{
GtkWidget *box, *label, *slider;
GtkAdjustment *adj;
const char *text;
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE);
switch (axis)
{
case X_AXIS:
text = "X axis";
break;
case Y_AXIS:
text = "Y axis";
break;
case Z_AXIS:
text = "Z axis";
break;
default:
g_assert_not_reached ();
}
label = gtk_label_new (text);
gtk_container_add (GTK_CONTAINER (box), label);
gtk_widget_show (label);
adj = gtk_adjustment_new (0.0, 0.0, 360.0, 1.0, 12.0, 0.0);
g_signal_connect (adj, "value-changed",
G_CALLBACK (on_axis_value_change),
GINT_TO_POINTER (axis));
slider = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adj);
gtk_container_add (GTK_CONTAINER (box), slider);
gtk_widget_set_hexpand (slider, TRUE);
gtk_widget_show (slider);
gtk_widget_show (box);
return box;
}
static GtkAdjustment *
create_levels_scale (gdouble value,
const gchar *left,
const gchar *right,
GtkWidget *table,
gint col)
{
GtkWidget *label;
GtkWidget *slider;
GtkWidget *spinbutton;
GtkAdjustment *adj;
label = gtk_label_new (left);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, col, col + 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
spinbutton = gimp_spin_button_new ((GtkObject **) &adj,
value, -100.0, 100.0,
1.0, 10.0, 0.0, 1.0, 0);
slider = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adj);
gtk_scale_set_draw_value (GTK_SCALE (slider), FALSE);
gtk_widget_set_size_request (slider, 100, -1);
gtk_table_attach_defaults (GTK_TABLE (table), slider, 1, 2, col, col + 1);
gtk_widget_show (slider);
label = gtk_label_new (right);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, col, col + 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), spinbutton, 3, 4, col, col + 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (spinbutton);
return adj;
}
int
main (int argc, char **argv)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *scale;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
gtk_widget_set_app_paintable (window, TRUE);
gtk_widget_add_events (window, GDK_POINTER_MOTION_MASK);
gtk_widget_set_app_paintable (window, TRUE);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
adjustment = gtk_adjustment_new (20, 0, 200, 1, 10, 0);
scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adjustment);
gtk_box_pack_end (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
label = gtk_label_new ("Event processing time (ms):");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_end (GTK_BOX (vbox), label, FALSE, FALSE, 0);
g_signal_connect (window, "motion-notify-event",
G_CALLBACK (on_motion_notify), NULL);
g_signal_connect (window, "draw",
G_CALLBACK (on_draw), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
static GtkWidget *
create_double_editor (RBObjectPropertyEditor *editor, const char *property, GParamSpec *pspec)
{
GParamSpecDouble *pdouble;
GtkWidget *control;
GtkAdjustment *adjustment;
pdouble = G_PARAM_SPEC_DOUBLE (pspec);
adjustment = gtk_adjustment_new (pdouble->default_value,
pdouble->minimum,
pdouble->maximum + pdouble->epsilon*2,
pdouble->epsilon*10,
0.1, 0.1);
control = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adjustment);
g_object_bind_property (editor->priv->object, property,
adjustment, "value",
G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
return control;
}
static GtkWidget *
create_int_editor (RBObjectPropertyEditor *editor, const char *property, GParamSpec *pspec)
{
GParamSpecInt *pint;
GtkWidget *control;
GtkAdjustment *adjustment;
pint = G_PARAM_SPEC_INT (pspec);
adjustment = gtk_adjustment_new (pint->default_value,
pint->minimum,
pint->maximum + 1,
1.0,
1.0, 1.0);
control = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adjustment);
gtk_scale_set_digits (GTK_SCALE (control), 0);
g_object_bind_property (editor->priv->object, property,
adjustment, "value",
G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
return control;
}
gboolean set_widgets_defaults(GtkWidget *mvbox, track_t *t, GdkRGBA *color)
{
GtkWidget *hbox, *vbox, *label, *hbox2,
*sep, *button, *img, *eventBox;
gint i = 0;
GdkRGBA buttonNormal = {1, 1, 1, 0.2};
GdkRGBA buttonSelected = {1, 1, 1, 0.6};
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start(GTK_BOX(mvbox), hbox, 0, 0, 1);
/* album image */
eventBox = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(eventBox), 0);
gtk_widget_set_events(eventBox, GDK_BUTTON_PRESS_MASK);
t->trackw.image = gtk_image_new();
gtk_container_add(GTK_CONTAINER(eventBox), t->trackw.image);
g_signal_connect(eventBox, "button_press_event", G_CALLBACK(show_player_callback), NULL);
gtk_box_pack_start(GTK_BOX(hbox), eventBox, 0, 0, 0);
/* track info: name, artist, album */
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, 0, 0, 0);
t->trackw.label.name = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(t->trackw.label.name), 0, 0);
/* create the layout to be able to scrol the label's contents */
t->trackw.layout.name = gtk_layout_new(NULL, NULL);
/* set size otherwise it won't show up */
gtk_widget_set_size_request(t->trackw.layout.name, SCROLL_SIZE_W, SCROLL_SIZE_H);
/* make layout's color the same as the window's */
gtk_widget_override_background_color(t->trackw.layout.name, GTK_STATE_FLAG_NORMAL, color);
gtk_layout_put(GTK_LAYOUT(t->trackw.layout.name), t->trackw.label.name, 0, 0);
t->trackw.label.artist = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(t->trackw.label.artist), 0, 0);
t->trackw.layout.artist = gtk_layout_new(NULL, NULL);
gtk_widget_set_size_request(t->trackw.layout.artist, SCROLL_SIZE_W-23, SCROLL_SIZE_H);
gtk_widget_override_background_color(t->trackw.layout.artist, GTK_STATE_FLAG_NORMAL, color);
gtk_layout_put(GTK_LAYOUT(t->trackw.layout.artist), t->trackw.label.artist, 0, 0);
t->trackw.label.album = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(t->trackw.label.album), 0, 0);
t->trackw.layout.album = gtk_layout_new(NULL, NULL);
gtk_widget_set_size_request(t->trackw.layout.album, SCROLL_SIZE_W-40, SCROLL_SIZE_H);
gtk_widget_override_background_color(t->trackw.layout.album, GTK_STATE_FLAG_NORMAL, color);
gtk_layout_put(GTK_LAYOUT(t->trackw.layout.album), t->trackw.label.album, 0, 0);
/* put the name, artist and album at their places */
gtk_box_pack_start(GTK_BOX(vbox), t->trackw.layout.name, 0, 0, 0);
hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, 0, 0, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
gtk_label_set_markup(GTK_LABEL(label), "<span font='Sans 11' font_style='italic'"
"color='#FFFFFF'>by </span>");
gtk_box_pack_start(GTK_BOX(hbox2), label, 0, 0, 0);
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.layout.artist, 0, 0, 0);
hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, 0, 0, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
gtk_label_set_markup(GTK_LABEL(label), "<span font='Sans 11' font_style='italic'"
"color='#FFFFFF'>from </span>");
gtk_box_pack_start(GTK_BOX(hbox2), label, 0, 0, 0);
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.layout.album, 0, 0, 0);
/* puts the genre, rating, year, and playcount */
hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, 0, 0, 0);
t->trackw.genre = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(t->trackw.genre), 0, 0);
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.genre, 0, 0, 0);
sep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start(GTK_BOX(hbox2), sep, 0, 0, 3);
for (i = 0; i < 5; i++) {
t->trackw.stars[i] = gtk_image_new();
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.stars[i], 0, 0, 1);
}
sep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start(GTK_BOX(hbox2), sep, 0, 0, 3);
t->trackw.year = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(t->trackw.year), 0, 0);
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.year, 0, 0, 0);
sep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start(GTK_BOX(hbox2), sep, 0, 0, 3);
t->trackw.playcount = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(t->trackw.playcount), 0, 0);
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.playcount, 0, 0, 0);
/* puts the current position, the slider showing the progress
* and track length */
hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, 0, 0, 0);
t->trackw.position = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(t->trackw.position), 0, 0);
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.position, 0, 0, 0);
t->trackw.slider = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, NULL);
gtk_widget_set_size_request(t->trackw.slider, 170, -1);
gtk_scale_set_draw_value(GTK_SCALE(t->trackw.slider), 0);
gtk_range_set_show_fill_level(GTK_RANGE(t->trackw.slider), 1);
gtk_range_set_restrict_to_fill_level(GTK_RANGE(t->trackw.slider), 0);
/*g_signal_connect(t->trackw.slider, "value-changed", G_CALLBACK(slider_value_changed), NULL);*/
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.slider, 0, 0, 0);
t->trackw.length = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(t->trackw.length), 0, 0);
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.length, 0, 0, 0);
/* the player controls */
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(mvbox), hbox, 0, 0, 0);
img = gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_xpm_data(prev_xpm));
button = gtk_button_new();
gtk_widget_override_background_color(button, GTK_STATE_FLAG_NORMAL, &buttonNormal);
gtk_widget_override_background_color(button, GTK_STATE_FLAG_ACTIVE, &buttonSelected);
gtk_container_add(GTK_CONTAINER(button), img);
g_signal_connect(button, "clicked", G_CALLBACK(button_callback),
GINT_TO_POINTER(BUTTON_PREV));
gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 0);
t->playerControls.playPause = gtk_image_new();
button = gtk_button_new();
gtk_widget_override_background_color(button, GTK_STATE_FLAG_NORMAL, &buttonNormal);
gtk_widget_override_background_color(button, GTK_STATE_FLAG_ACTIVE, &buttonSelected);
gtk_container_add(GTK_CONTAINER(button), t->playerControls.playPause);
g_signal_connect(button, "clicked", G_CALLBACK(button_callback),
GINT_TO_POINTER(BUTTON_PLAY_PAUSE));
gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 0);
img = gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_xpm_data(next_xpm));
button = gtk_button_new();
gtk_widget_override_background_color(button, GTK_STATE_FLAG_NORMAL, &buttonNormal);
gtk_widget_override_background_color(button, GTK_STATE_FLAG_ACTIVE, &buttonSelected);
gtk_container_add(GTK_CONTAINER(button), img);
g_signal_connect(button, "clicked", G_CALLBACK(button_callback),
GINT_TO_POINTER(BUTTON_NEXT));
gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 0);
sep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start(GTK_BOX(hbox), sep, 0, 0, 2);
t->playerControls.repeat = gtk_image_new();
button = gtk_button_new();
gtk_widget_override_background_color(button, GTK_STATE_FLAG_NORMAL, &buttonNormal);
gtk_widget_override_background_color(button, GTK_STATE_FLAG_ACTIVE, &buttonSelected);
gtk_container_add(GTK_CONTAINER(button), t->playerControls.repeat);
g_signal_connect(button, "clicked", G_CALLBACK(button_callback),
GINT_TO_POINTER(BUTTON_REPEAT));
gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 0);
t->playerControls.shuffle = gtk_image_new();
button = gtk_button_new();
gtk_widget_override_background_color(button, GTK_STATE_FLAG_NORMAL, &buttonNormal);
gtk_widget_override_background_color(button, GTK_STATE_FLAG_ACTIVE, &buttonSelected);
gtk_container_add(GTK_CONTAINER(button), t->playerControls.shuffle);
g_signal_connect(button, "clicked", G_CALLBACK(button_callback),
GINT_TO_POINTER(BUTTON_SHUFFLE));
gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 0);
return TRUE;
}
int main(int argc, char *argv[])
{
printf("%s \nPlease report any bug to %s\n", PACKAGE_STRING, PACKAGE_BUGREPORT);
//printf("number of arg = %d, argv = %s\n", argc, argv[1]);
/*printf("argc = %d\n", argc);
if (argv[1] != NULL) {
if (strstr (argv[1],"debug") != NULL) {
debug = TRUE;
printf("debug = TRUE\n");
}
}
DEBUG("debug is true\n");*/
gchar *filename;
int i = 0;
gint initialWindowHeight = 170;
guint timeoutEvent, intervalDisplaySpectro;
GtkWidget *pVBox[4], *pHBox[13], *menuBar, *menu, *submenu, *menuItem, *submenuItem, *button, *frame, *image, *label, *widget;
GdkColor color;
Spectrum3dGui spectrum3dGui;
GSList *radio_menu_group;
GError **error;
#if defined (GTKGLEXT3) || defined (GTKGLEXT1)
GdkGLConfig *glconfig;
#endif
gst_init (NULL, NULL);
gtk_init (&argc, &argv);
get_saved_values();
intervalDisplaySpectro = (guint)spectrum3d.interval_display;
#if defined (GTKGLEXT3) || defined (GTKGLEXT1)
gtk_gl_init(NULL, NULL);
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE);
if (glconfig == NULL)
{
g_print ("\n*** Cannot find the double-buffered visual.\n");
g_print ("\n*** Trying single-buffered visual.\n");
/* Try single-buffered visual */
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH);
if (glconfig == NULL)
{
g_print ("*** No appropriate OpenGL-capable visual found.\n");
exit (1);
}
}
#endif
initGstreamer();
init_audio_values();
init_display_values(&spectrum3dGui);
spectrum3dGui.mainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (spectrum3dGui.mainWindow, 700, initialWindowHeight);
gtk_widget_realize(spectrum3dGui.mainWindow);
gtk_window_set_title(GTK_WINDOW(spectrum3dGui.mainWindow), PACKAGE_NAME);
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "spectrum3d.png", NULL);
gtk_window_set_icon(GTK_WINDOW(spectrum3dGui.mainWindow), gdk_pixbuf_new_from_file (filename, error));
g_signal_connect (G_OBJECT (spectrum3dGui.mainWindow), "destroy", G_CALLBACK (quit_spectrum3d), NULL);
#ifdef GTK3
gtk_container_set_reallocate_redraws (GTK_CONTAINER (spectrum3dGui.mainWindow), TRUE);
#endif
#ifdef GTK3
for (i = 0; i < 4; i++) {
pVBox[i] = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
}
pHBox[0] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
for (i = 1; i < 12; i++) {
pHBox[i] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
}
pHBox[12] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#elif defined GTK2
for (i = 0; i < 4; i++) {
pVBox[i] = gtk_vbox_new(FALSE, 0);
}
pHBox[0] = gtk_hbox_new(TRUE, 0);
for (i = 1; i < 12; i++) {
pHBox[i] = gtk_hbox_new(FALSE, 0);
}
pHBox[12] = gtk_hbox_new(TRUE, 0);
#endif
gtk_container_add(GTK_CONTAINER(spectrum3dGui.mainWindow), pVBox[1]);
gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[0], FALSE, FALSE, 0);
/* Menu */
menuBar = gtk_menu_bar_new();
menu = gtk_menu_new(); // 'Quit' submenu
menuItem = gtk_menu_item_new_with_label("Quit");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(gtk_main_quit), NULL);
menuItem = gtk_menu_item_new_with_label("Quit");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem);
menu = gtk_menu_new(); // 'Edit' submenu
menuItem = gtk_menu_item_new_with_label("Preferences");
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onPreferences), &spectrum3dGui);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
menuItem = gtk_menu_item_new_with_label("Edit");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem);
menu = gtk_menu_new(); // 'Sound' submenu
menuItem = gtk_menu_item_new_with_label("Sound");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem);
submenu = gtk_menu_new();// 'Play test sound' sub-submenu
spectrum3dGui.checkMenuTestSound = gtk_check_menu_item_new_with_label("Test Sound");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), spectrum3dGui.checkMenuTestSound);
g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuTestSound), "activate", G_CALLBACK(menu_check_test_sound), &spectrum3dGui);
menu = gtk_menu_new(); // 'View' submenu
menuItem = gtk_menu_item_new_with_label("View");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem);
submenu = gtk_menu_new();// 'viewType' sub-submenu
menuItem = gtk_menu_item_new_with_label("Perspective");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), submenu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
spectrum3dGui.radio3D = gtk_radio_menu_item_new_with_label(NULL, "3D (D)");
radio_menu_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(spectrum3dGui.radio3D));
g_signal_connect(G_OBJECT(spectrum3dGui.radio3D), "toggled", G_CALLBACK(change_perspective), spectrum3dGui.radio3D);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.radio3D);
spectrum3dGui.radio3Dflat = gtk_radio_menu_item_new_with_label(radio_menu_group, "3D flat (F)");
radio_menu_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(spectrum3dGui.radio3Dflat));
g_signal_connect(G_OBJECT(spectrum3dGui.radio3Dflat), "toggled", G_CALLBACK(change_perspective), spectrum3dGui.radio3Dflat);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.radio3Dflat);
spectrum3dGui.radio2D = gtk_radio_menu_item_new_with_label(radio_menu_group, "2D (D)");
radio_menu_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(spectrum3dGui.radio2D));
g_signal_connect(G_OBJECT(spectrum3dGui.radio2D), "toggled", G_CALLBACK(change_perspective), spectrum3dGui.radio2D);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.radio2D);
submenu = gtk_menu_new();// 'Scale' sub-submenu
menuItem = gtk_menu_item_new_with_label("Scale");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), submenu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
spectrum3dGui.checkMenuText = gtk_check_menu_item_new_with_label("Text (T)");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(spectrum3dGui.checkMenuText), TRUE);
g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuText), "activate", G_CALLBACK(check_menu_text), &spectrum3dGui);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.checkMenuText);
spectrum3dGui.checkMenuLines = gtk_check_menu_item_new_with_label("Lines (L)");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(spectrum3dGui.checkMenuLines), TRUE);
g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuLines), "activate", G_CALLBACK(check_menu_lines), &spectrum3dGui);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.checkMenuLines);
spectrum3dGui.checkMenuPointer = gtk_check_menu_item_new_with_label("Pointer (P)");
g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuPointer), "activate", G_CALLBACK(check_menu_pointer), &spectrum3dGui);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.checkMenuPointer);
submenu = gtk_menu_new();// 'Change/reset view' sub-submenu
menuItem = gtk_menu_item_new_with_label("Change/reset view");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), submenu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
spectrum3dGui.reset = gtk_menu_item_new_with_label("Reset view (R)");
gtk_widget_set_tooltip_text (spectrum3dGui.reset, "Reset the view as if Spectrum3d was just started");
g_signal_connect(G_OBJECT(spectrum3dGui.reset), "activate", G_CALLBACK(reset_view), spectrum3dGui.reset);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.reset);
spectrum3dGui.front = gtk_menu_item_new_with_label("Front view (O)");
gtk_widget_set_tooltip_text (spectrum3dGui.front, "2D view showing frequency versus intensity of the sound; shows a snapshot of the harmonics at a given time");
g_signal_connect(G_OBJECT(spectrum3dGui.front), "activate", G_CALLBACK(front_view), spectrum3dGui.front);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.front);
submenuItem = gtk_menu_item_new_with_label("Preset view");
gtk_widget_set_tooltip_text (submenuItem, "Set the view with the chosen preset values");
g_signal_connect(G_OBJECT(submenuItem), "activate", G_CALLBACK(set_view_from_preset), submenuItem);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), submenuItem);
menu = gtk_menu_new(); // 'Help...' submenu
menuItem = gtk_menu_item_new_with_label("Shortcuts");
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onShortcuts), (GtkWidget*) spectrum3dGui.mainWindow);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
#ifdef HAVE_LIBGEIS
menuItem = gtk_menu_item_new_with_label("Gestures Shortcuts");
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onGesturesShortcuts), (GtkWidget*) spectrum3dGui.mainWindow);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
#endif
menuItem = gtk_menu_item_new_with_label("About...");
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onAbout), (GtkWidget*) spectrum3dGui.mainWindow);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
menuItem = gtk_menu_item_new_with_label("Quick start");
g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onQuickStart), (GtkWidget*) spectrum3dGui.mainWindow);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
menuItem = gtk_menu_item_new_with_label("Help");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem);
gtk_box_pack_start(GTK_BOX(pHBox[0]), menuBar, FALSE, TRUE, 0);
/* SourceButtons to set type of source (none, audio file, microphone) */
spectrum3dGui.stop = gtk_button_new();
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "stop.png", NULL);
image = gtk_image_new_from_file(filename);
gtk_button_set_image(GTK_BUTTON(spectrum3dGui.stop),image);
gdk_color_parse ("gold",&color);
gtk_widget_set_name(spectrum3dGui.stop, "stop");
gtk_widget_modify_bg(GTK_WIDGET(spectrum3dGui.stop), GTK_STATE_NORMAL, &color);
gtk_widget_modify_bg(GTK_WIDGET(spectrum3dGui.stop), GTK_STATE_PRELIGHT, &color);
gtk_widget_set_tooltip_text (spectrum3dGui.stop, "Stop playing everything; no source of playing");
gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[1], FALSE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.stop, FALSE, TRUE, 2);
g_signal_connect(G_OBJECT(spectrum3dGui.stop), "clicked", G_CALLBACK(change_source_button), &spectrum3dGui);
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "microphone_grey.png", NULL);
image = gtk_image_new_from_file(filename);
spectrum3dGui.mic = gtk_button_new();
gtk_button_set_image (GTK_BUTTON(spectrum3dGui.mic), image);
gtk_widget_set_name(spectrum3dGui.mic, "mic");
gtk_widget_set_tooltip_text (spectrum3dGui.mic, "Source is microphone; select this to record something and then load it");
gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.mic, FALSE, TRUE, 2);
g_signal_connect(G_OBJECT(spectrum3dGui.mic), "clicked", G_CALLBACK(change_source_button), &spectrum3dGui);
spectrum3dGui.file = gtk_button_new();
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "file_grey.png", NULL);
image = gtk_image_new_from_file(filename);
gtk_button_set_image(GTK_BUTTON(spectrum3dGui.file),image);
gtk_widget_set_name(spectrum3dGui.file, "file");
gtk_widget_set_tooltip_text (spectrum3dGui.file, "Source is an audio file");
gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.file, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(spectrum3dGui.file), "clicked", G_CALLBACK(change_source_button), &spectrum3dGui);
spectrum3dGui.reload = gtk_button_new();
image = gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(spectrum3dGui.reload),image);
gtk_widget_set_sensitive (spectrum3dGui.reload, FALSE);
gtk_widget_set_tooltip_text (spectrum3dGui.reload, "Reload audio file (usefull if some audio parameters like equalizer or filters have been changed)");
gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.reload, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(spectrum3dGui.reload), "clicked", G_CALLBACK(load_audio_file), NULL);
widget = gtk_check_button_new_with_label("Analyse in\nrealtime");
gtk_widget_set_tooltip_text (GTK_WIDGET(widget), "If checked, harmonics will be analysed and displayed at the same time; if unchecked, harmonics will be analysed first, then displayed for the whole audio file, then it can be played afterwards");
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(widget), TRUE);
g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(set_analyse_in_rt), &spectrum3dGui);
/* separator */
#ifdef GTK3
widget = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
#elif defined GTK2
widget = gtk_vseparator_new();
#endif
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 5);
/* "Play/Pause" button */
playButton = gtk_button_new();
gtk_widget_set_tooltip_text (playButton, "Play/Pause the audio stream");
setPlayButtonIcon();
gtk_widget_set_size_request (playButton, 50, 20);
gtk_box_pack_start(GTK_BOX(pHBox[1]), playButton, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(playButton), "clicked", G_CALLBACK(playFromSource), "NO_MESSAGE");
/* "Stop" button */
button = gtk_button_new();
gtk_widget_set_tooltip_text (button, "Stop playing audio stream");
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_STOP, GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(button),image);
gtk_box_pack_start(GTK_BOX(pHBox[1]), button, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(on_stop), NULL);
/* "Record" button */
spectrum3dGui.record = gtk_button_new();
gtk_widget_set_tooltip_text (spectrum3dGui.record, "Record from microphone");
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_RECORD, GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(spectrum3dGui.record),image);
gtk_widget_set_sensitive (spectrum3dGui.record, FALSE);
gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.record, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(spectrum3dGui.record), "clicked", G_CALLBACK(record_window), NULL);
/* separator */
#ifdef GTK3
widget = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
#elif defined GTK2
widget = gtk_vseparator_new();
#endif
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 5);
/* JACK check button */
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "qjackctl.png", NULL);
image = gtk_image_new_from_file(filename);
widget = gtk_check_button_new ();
gtk_button_set_image (GTK_BUTTON(widget), image);
gtk_widget_set_tooltip_text (widget, "Use Jack-Audio-Connection-Kit (JACK)");
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(use_jack), &spectrum3dGui);
/* separator */
#ifdef GTK3
widget = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
#elif defined GTK2
widget = gtk_vseparator_new();
#endif
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 5);
/* Button to open the Filter and Equalizer window */
// create effectsWindow first without showing it
effects_window(&spectrum3dGui);
// then create a button that will call its display when clicked
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "equalizer.png", NULL);
image = gtk_image_new_from_file(filename);
widget = gtk_button_new();
gtk_button_set_image (GTK_BUTTON(widget), image);
gtk_widget_set_tooltip_text (widget, "Show/Hide the filter and equalizer window");
gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(show_effects_window), &spectrum3dGui);
/* Time label */
label=gtk_label_new("Time : ");
gtk_box_pack_start(GTK_BOX(pHBox[5]), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[5], FALSE, FALSE, 2);
/* Progress & seek scale */
#ifdef GTK3
scaleSeek = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0.0, 100.0, 1);
#elif defined GTK2
scaleSeek = gtk_hscale_new_with_range (0.0, 100.0, 1);
#endif
gtk_scale_set_draw_value (GTK_SCALE (scaleSeek), FALSE);
//gtk_scale_set_value_pos (GTK_SCALE (pScaleSeek), GTK_POS_TOP);
gtk_range_set_value (GTK_RANGE (scaleSeek), 0);
gtk_widget_set_size_request (scaleSeek, 500, 20);
gtk_box_pack_start(GTK_BOX(pHBox[5]), scaleSeek, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(scaleSeek), "value-changed", G_CALLBACK(on_seek), NULL);
timeLabel=gtk_label_new(" 0:00 / 0:00 ");
gtk_box_pack_start(GTK_BOX(pHBox[5]), timeLabel, FALSE, FALSE, 0);
/* Create drawing area */
if (externalWindow == FALSE){
/* Resize spectrum3dGui.mainWindow to contain drawing_area; using gtk_window_set_defaut() allows to shrink the window (gtk_widget_set_size_request() does not allow to shrink the window below the requested size); */
gtk_window_set_default_size (GTK_WINDOW(spectrum3dGui.mainWindow), (gint)spectrum3d.width, initialWindowHeight + (gint)spectrum3d.height);
//gtk_widget_realize(spectrum3dGui.mainWindow);
spectrum3dGui.drawing_area = gtk_drawing_area_new ();
#if defined (GTKGLEXT3) || defined (GTKGLEXT1)
/* Set OpenGL-capability to the widget */
gtk_widget_set_gl_capability (spectrum3dGui.drawing_area,
glconfig,
NULL,
TRUE,
GDK_GL_RGBA_TYPE);
#endif
/* drawing_area has to be put in vBox AFTER the call to gtk_widget_set_gl_capability() (if GtkGlExt is used) and BEFORE the call to the sdl-gtk hack (if sdl is used)*/
gtk_box_pack_start (GTK_BOX (pVBox[1]), spectrum3dGui.drawing_area, TRUE, TRUE, 0);
#ifdef HAVE_LIBSDL
/* Hack to get SDL to use GTK window */
{ char SDL_windowhack[32];
sprintf(SDL_windowhack,"SDL_WINDOWID=%ld",
GDK_WINDOW_XID(gtk_widget_get_window(spectrum3dGui.drawing_area)));
// GDK_WINDOW_XID( spectrum3dGui.drawing_area->window))); pour GTK2??
putenv(SDL_windowhack);
printf("%s\n", SDL_windowhack);
}
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError());
exit(1);
}
#endif
g_signal_connect (spectrum3dGui.mainWindow, "key-press-event", G_CALLBACK (on_key_press), &spectrum3dGui);
g_signal_connect (spectrum3dGui.mainWindow, "key-release-event", G_CALLBACK (on_key_release), &spectrum3dGui);
g_signal_connect (spectrum3dGui.mainWindow, "motion-notify-event", G_CALLBACK (on_mouse_motion), NULL);
g_signal_connect (spectrum3dGui.mainWindow, "scroll-event", G_CALLBACK (on_mouse_scroll), NULL);
g_signal_connect (G_OBJECT (spectrum3dGui.drawing_area), "configure_event", G_CALLBACK (configure_event), NULL);
gtk_widget_add_events (spectrum3dGui.mainWindow, gtk_widget_get_events (spectrum3dGui.mainWindow) | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_SCROLL_MASK);
}
else {
create_external_window_drawing_area(&spectrum3dGui);
}
/* Starting value of the display */
frame = gtk_frame_new("Start value of display (in Hz)");
gtk_widget_set_tooltip_text (frame, "The lower displayed frequency (in herz)");
spectrum3dGui.adjustStart = gtk_adjustment_new(0, 0, 9000, ((gdouble)hzStep * (gdouble)zoomFactor), (((gdouble)hzStep * (gdouble)zoomFactor) * 10), 0);
#ifdef GTK3
pScaleStart = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(spectrum3dGui.adjustStart));
#elif defined GTK2
pScaleStart = gtk_hscale_new(GTK_ADJUSTMENT(spectrum3dGui.adjustStart));
#endif
gtk_scale_set_digits (GTK_SCALE(pScaleStart), 0);
gtk_scale_set_value_pos(GTK_SCALE(pScaleStart), GTK_POS_RIGHT);
gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[11], FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), pScaleStart);
g_signal_connect(G_OBJECT(pScaleStart), "value-changed", G_CALLBACK(change_start), &spectrum3dGui);
g_signal_connect(G_OBJECT(pScaleStart), "format-value", G_CALLBACK(format_value_start), NULL);
g_signal_connect(G_OBJECT(pScaleStart), "value-changed", G_CALLBACK(getTextDisplayLabel), &spectrum3dGui);
/* Range of display */
frame = gtk_frame_new("Range of display (in Hz)");
gtk_widget_set_tooltip_text (frame, "The range of the displayed frequency (in herz)");
spectrum3dGui.adjustBands = gtk_adjustment_new(1000, 20, 1000, 10, 50, 0);
#ifdef GTK3
spectrum3dGui.scaleBands = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(spectrum3dGui.adjustBands));
#elif defined GTK2
spectrum3dGui.scaleBands = gtk_hscale_new(GTK_ADJUSTMENT(spectrum3dGui.adjustBands));
#endif
gtk_scale_set_digits (GTK_SCALE(spectrum3dGui.scaleBands), 0);
gtk_scale_set_value_pos(GTK_SCALE(spectrum3dGui.scaleBands), GTK_POS_RIGHT);
gtk_container_add(GTK_CONTAINER(frame), spectrum3dGui.scaleBands);
gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(spectrum3dGui.scaleBands), "value-changed", G_CALLBACK(change_bands), &spectrum3dGui);
g_signal_connect(G_OBJECT(spectrum3dGui.scaleBands), "format-value", G_CALLBACK(format_value_bands), NULL);
g_signal_connect(G_OBJECT(spectrum3dGui.scaleBands), "value-changed", G_CALLBACK(getTextDisplayLabel), &spectrum3dGui);
/* "x" label */
label=gtk_label_new("x");
gtk_container_add(GTK_CONTAINER(pHBox[11]), label);
/* Factor that multiplies the range of display */
frame = gtk_frame_new("");
gtk_widget_set_tooltip_text (frame, "Factor that multiplies the frequency range, to make it larger");
spectrum3dGui.cbRange = gtk_combo_box_text_new();
gtk_container_add(GTK_CONTAINER(frame), spectrum3dGui.cbRange);
gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0);
for (i = 1; i <= 20; i++){
gchar text[4];
sprintf(text, "%d", i);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(spectrum3dGui.cbRange), text);
}
gtk_combo_box_set_active(GTK_COMBO_BOX(spectrum3dGui.cbRange), 0);
g_signal_connect( G_OBJECT(spectrum3dGui.cbRange), "changed", G_CALLBACK( cb_range_changed ), &spectrum3dGui );
g_signal_connect( G_OBJECT(spectrum3dGui.cbRange), "changed", G_CALLBACK(getTextDisplayLabel), &spectrum3dGui );
/* Label that shows starting value, ending value and range of display */
frame = gtk_frame_new("Values displayed");
gtk_widget_set_tooltip_text (frame, "The lower and the highest displayed value (in herz), and their range");
displayLabel=gtk_label_new("");
gtk_container_add(GTK_CONTAINER(frame), displayLabel);
getTextDisplayLabel(NULL, &spectrum3dGui);
gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0);
/* 'Gain' Gtk Scale */
frame = gtk_frame_new("Display Gain");
gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 10);
filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "gain.png", NULL);
image = gtk_image_new_from_file(filename);
spectrum3dGui.scaleGain = gtk_scale_button_new (GTK_ICON_SIZE_LARGE_TOOLBAR, 0, 1, 0.01, NULL);
gtk_button_set_image(GTK_BUTTON(spectrum3dGui.scaleGain),image);
//gtk_button_set_label (GTK_BUTTON(spectrum3dGui.scaleGain), "GAIN");
gtk_container_add(GTK_CONTAINER(frame), spectrum3dGui.scaleGain);
//gtk_box_pack_start(GTK_BOX(pHBox[11]), pScaleGain, FALSE, FALSE, 0);
//gtk_widget_set_size_request (pScaleGain, 200, 20);
//gtk_scale_set_value_pos(GTK_SCALE(pScaleGain), GTK_POS_RIGHT);
gtk_widget_set_tooltip_text (spectrum3dGui.scaleGain, "Adjust the displayed level of the intensity of the sound");
gtk_scale_button_set_value(GTK_SCALE_BUTTON(spectrum3dGui.scaleGain), 0.2);
// FIXME error message here with the previous line : gtk_image_set_from_stock: assertion `GTK_IS_IMAGE (image)' failed; it could be a bug in Gtk
//g_object_set (pScaleGain, "update-policy", GTK_UPDATE_DISCONTINUOUS, NULL);
g_signal_connect(G_OBJECT(spectrum3dGui.scaleGain), "value-changed", G_CALLBACK(change_gain), NULL);
#ifdef HAVE_LIBGEIS
setupGeis();
#endif
gtk_widget_show_all (spectrum3dGui.mainWindow);
//timeoutEvent = g_timeout_add (100, (GSourceFunc)sdl_event, &spectrum3dGui);
spectrum3d.timeoutExpose = g_timeout_add (intervalDisplaySpectro, (GSourceFunc)display_spectro, &spectrum3dGui);
printf("Showing Gtk GUI\n");
gtk_main ();
/* Quit everything */
#ifdef HAVE_LIBGEIS
geisQuit();
#endif
on_stop();
g_source_remove(spectrum3d.timeoutExpose);
#ifdef HAVE_LIBSDL
//g_source_remove(timeoutEvent);
SDL_Quit();
#endif
print_rc_file();
printf("Quit everything\nGood Bye!\n");
return 0;
}
void
create_brushpage (GtkNotebook *notebook)
{
GtkWidget *box1, *box2, *box3, *thispage;
GtkWidget *view;
GtkWidget *tmpw, *table;
GtkWidget *frame;
GtkWidget *combo;
GtkWidget *label;
GtkSizeGroup *group;
GtkTreeSelection *selection;
label = gtk_label_new_with_mnemonic (_("_Brush"));
thispage = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (thispage), 12);
gtk_widget_show (thispage);
box1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (thispage), box1, TRUE,TRUE,0);
gtk_widget_show (box1);
view = create_one_column_list (box1, brush_select_file);
brush_list = view;
brush_list_store =
GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (view)));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
gtk_widget_show (box2);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (box2), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
brush_preview = tmpw = gimp_preview_area_new ();
gtk_widget_set_size_request (brush_preview, 100, 100);
gtk_container_add (GTK_CONTAINER (frame), tmpw);
gtk_widget_show (tmpw);
g_signal_connect (brush_preview, "size-allocate",
G_CALLBACK (brush_preview_size_allocate), NULL);
box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_box_pack_end (GTK_BOX (box2), box3, FALSE, FALSE,0);
gtk_widget_show (box3);
tmpw = gtk_label_new (_("Gamma:"));
gtk_misc_set_alignment (GTK_MISC (tmpw), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (box3), tmpw, FALSE, FALSE,0);
gtk_widget_show (tmpw);
brush_gamma_adjust = GTK_ADJUSTMENT (gtk_adjustment_new (pcvals.brushgamma,
0.5, 3.0, 0.1, 0.1, 1.0));
tmpw = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, brush_gamma_adjust);
gtk_widget_set_size_request (GTK_WIDGET (tmpw), 100, 30);
gtk_scale_set_draw_value (GTK_SCALE (tmpw), FALSE);
gtk_scale_set_digits (GTK_SCALE (tmpw), 2);
gtk_box_pack_start (GTK_BOX (box3), tmpw, FALSE, FALSE, 0);
gtk_widget_show (tmpw);
g_signal_connect_swapped (brush_gamma_adjust, "value-changed",
G_CALLBACK (update_brush_preview),
pcvals.selected_brush);
gimp_help_set_help_data
(tmpw, _("Changes the gamma (brightness) of the selected brush"), NULL);
box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (thispage), box3, FALSE, FALSE,0);
gtk_widget_show (box3);
group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
tmpw = gtk_label_new (_("Select:"));
gtk_misc_set_alignment (GTK_MISC (tmpw), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (box3), tmpw, FALSE, FALSE, 0);
gtk_widget_show (tmpw);
gtk_size_group_add_widget (group, tmpw);
g_object_unref (group);
combo = gimp_drawable_combo_box_new (validdrawable, NULL);
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), -1,
G_CALLBACK (brushdmenuselect),
NULL);
gtk_box_pack_start (GTK_BOX (box3), combo, TRUE, TRUE, 0);
gtk_widget_show (combo);
tmpw = gtk_button_new_from_stock (GTK_STOCK_SAVE_AS);
gtk_box_pack_start (GTK_BOX (box3),tmpw, FALSE, FALSE, 0);
g_signal_connect (tmpw, "clicked", G_CALLBACK (savebrush), NULL);
gtk_widget_show (tmpw);
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_box_pack_start (GTK_BOX (thispage), table, FALSE, FALSE, 0);
gtk_widget_show (table);
brush_aspect_adjust = (GtkAdjustment *)
gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("Aspect ratio:"),
150, -1, pcvals.brush_aspect,
-1.0, 1.0, 0.1, 0.1, 2,
TRUE, 0, 0,
_("Specifies the aspect ratio of the brush"),
NULL);
gtk_size_group_add_widget (group,
GIMP_SCALE_ENTRY_LABEL (brush_aspect_adjust));
g_signal_connect (brush_aspect_adjust, "value-changed",
G_CALLBACK (brush_asepct_adjust_cb), &pcvals.brush_aspect);
brush_relief_adjust = (GtkAdjustment *)
gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
_("Relief:"),
150, -1, pcvals.brush_relief,
0.0, 100.0, 1.0, 10.0, 1,
TRUE, 0, 0,
_("Specifies the amount of embossing to apply to the image (in percent)"),
NULL);
gtk_size_group_add_widget (group,
GIMP_SCALE_ENTRY_LABEL (brush_relief_adjust));
g_signal_connect (brush_relief_adjust, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&pcvals.brush_relief);
brush_select (selection, FALSE);
readdirintolist ("Brushes", view, pcvals.selected_brush);
/*
* This is so the "changed signal won't get sent to the brushes' list
* and reset the gamma and stuff.
* */
gtk_widget_grab_focus (brush_list);
gtk_notebook_append_page_menu (notebook, thispage, label, NULL);
}
// static
wxVisualAttributes
wxSlider::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
{
return GetDefaultAttributesFromGTKWidget(gtk_scale_new(GTK_ORIENTATION_VERTICAL, NULL));
}
bool wxSlider::Create(wxWindow *parent,
wxWindowID id,
int value,
int minValue,
int maxValue,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name)
{
m_pos = value;
m_scrollEventType = GTK_SCROLL_NONE;
m_needThumbRelease = false;
m_blockScrollEvent = false;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxSlider creation failed") );
return false;
}
const bool isVertical = (style & wxSL_VERTICAL) != 0;
m_scale = gtk_scale_new(GtkOrientation(isVertical), NULL);
if (style & wxSL_MIN_MAX_LABELS)
{
gtk_widget_show( m_scale );
m_widget = gtk_box_new(GtkOrientation(!isVertical), 0);
gtk_box_pack_start(GTK_BOX(m_widget), m_scale, true, true, 0);
GtkWidget* box = gtk_box_new(GtkOrientation(isVertical), 0);
gtk_widget_show(box);
gtk_box_pack_start(GTK_BOX(m_widget), box, true, true, 0);
m_minLabel = gtk_label_new(NULL);
gtk_widget_show( m_minLabel );
gtk_box_pack_start(GTK_BOX(box), m_minLabel, false, false, 0);
// expanding empty space between the min/max labels
GtkWidget *space = gtk_label_new(NULL);
gtk_widget_show( space );
gtk_box_pack_start(GTK_BOX(box), space, true, false, 0);
m_maxLabel = gtk_label_new(NULL);
gtk_widget_show( m_maxLabel );
gtk_box_pack_end(GTK_BOX(box), m_maxLabel, false, false, 0);
}
else
{
m_widget = m_scale;
m_maxLabel = NULL;
m_minLabel = NULL;
}
g_object_ref(m_widget);
const bool showValueLabel = (style & wxSL_VALUE_LABEL) != 0;
gtk_scale_set_draw_value(GTK_SCALE (m_scale), showValueLabel );
if ( showValueLabel )
{
// position the label appropriately: notice that wxSL_DIRECTION flags
// specify the position of the ticks, not label, under MSW and so the
// label is on the opposite side
GtkPositionType posLabel;
if ( style & wxSL_VERTICAL )
{
if ( style & wxSL_LEFT )
posLabel = GTK_POS_RIGHT;
else // if ( style & wxSL_RIGHT ) -- this is also the default
posLabel = GTK_POS_LEFT;
}
else // horizontal slider
{
if ( style & wxSL_TOP )
posLabel = GTK_POS_BOTTOM;
else // if ( style & wxSL_BOTTOM) -- this is again the default
posLabel = GTK_POS_TOP;
}
gtk_scale_set_value_pos( GTK_SCALE(m_scale), posLabel );
}
// Keep full precision in position value
gtk_scale_set_digits(GTK_SCALE (m_scale), -1);
if (style & wxSL_INVERSE)
gtk_range_set_inverted( GTK_RANGE(m_scale), TRUE );
g_signal_connect(m_scale, "button_press_event", G_CALLBACK(gtk_button_press_event), this);
g_signal_connect(m_scale, "button_release_event", G_CALLBACK(gtk_button_release_event), this);
g_signal_connect(m_scale, "move_slider", G_CALLBACK(gtk_move_slider), this);
g_signal_connect(m_scale, "format_value", G_CALLBACK(gtk_format_value), NULL);
g_signal_connect(m_scale, "value_changed", G_CALLBACK(gtk_value_changed), this);
gulong handler_id = g_signal_connect(m_scale, "event_after", G_CALLBACK(gtk_event_after), this);
g_signal_handler_block(m_scale, handler_id);
SetRange( minValue, maxValue );
// don't call the public SetValue() as it won't do anything unless the
// value really changed
GTKSetValue( value );
m_parent->DoAddChild( this );
PostCreation(size);
return true;
}
void sndstretch_config(void)
{
GtkWidget * vbox;
GtkWidget * speed_scale, * pitch_scale, * scale_scale;
GtkWidget * speed_spin, * pitch_spin, * scale_spin;
GtkWidget * speed_hbox, * pitch_hbox, * scale_hbox, * opt_hbox;
GtkWidget * speed_frame, * pitch_frame, * scale_frame, * opt_frame;
GtkWidget * logohbox;
GtkWidget * logobutton;
GtkWidget * volume_toggle;
GtkWidget * overlap_toggle;
if (sndstretch_config_dialog != NULL)
return;
sndstretch_config_dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint(GTK_WINDOW(sndstretch_config_dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_widget_show(sndstretch_config_dialog);
GtkWidget * logo = gtk_image_new_from_pixbuf (gdk_pixbuf_new_from_xpm_data
((const gchar * *) sndstretch_xmms_logo_xpm));
logobutton = gtk_button_new();
gtk_button_set_relief(GTK_BUTTON(logobutton), GTK_RELIEF_NONE);
gtk_container_add(GTK_CONTAINER(logobutton), logo);
g_signal_connect (logobutton, "clicked", (GCallback)
sndstretch_config_logobutton_cb, NULL);
gtk_widget_set_can_default (logobutton, TRUE);
logohbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0); // to make it rightbound
gtk_box_pack_end(GTK_BOX(logohbox), logobutton, FALSE, TRUE, 4);
SS.speed_adj = (GtkAdjustment *) gtk_adjustment_new (100 * log (SS.speed) /
log (2), -100, 100 + 10, 2, 10, 0);
SS.pitch_adj = (GtkAdjustment *) gtk_adjustment_new (120 * log (SS.pitch) /
log (2), -120, 120 + 10, 2, 10, 0);
SS.scale_adj = (GtkAdjustment *) gtk_adjustment_new (100 * log (SS.scale) /
log (2), -100, 100 + 10, 2, 10, 0);
volume_toggle = gtk_check_button_new_with_label(_("Volume corr."));
overlap_toggle = gtk_check_button_new_with_label(_("Short Overlap"));
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(volume_toggle), SS.volume_corr );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(overlap_toggle), SS.short_overlap );
g_signal_connect (SS.speed_adj, "value-changed", (GCallback)
speed_change_cb, NULL);
g_signal_connect (SS.pitch_adj, "value-changed", (GCallback)
pitch_change_cb, NULL);
g_signal_connect (SS.scale_adj, "value-changed", (GCallback)
scale_change_cb, NULL);
g_signal_connect (volume_toggle, "toggled", (GCallback) volume_toggle_cb,
NULL);
g_signal_connect (overlap_toggle, "toggled", (GCallback) overlap_toggle_cb,
NULL);
speed_scale = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(SS.speed_adj));
pitch_scale = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(SS.pitch_adj));
scale_scale = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(SS.scale_adj));
gtk_scale_set_draw_value (GTK_SCALE(speed_scale),FALSE);
gtk_scale_set_draw_value (GTK_SCALE(pitch_scale),FALSE);
gtk_scale_set_draw_value (GTK_SCALE(scale_scale),FALSE);
speed_spin = gtk_spin_button_new(GTK_ADJUSTMENT(SS.speed_adj),1.0,2);
pitch_spin = gtk_spin_button_new(GTK_ADJUSTMENT(SS.pitch_adj),1.0,2);
scale_spin = gtk_spin_button_new(GTK_ADJUSTMENT(SS.scale_adj),1.0,2);
gtk_entry_set_max_length (GTK_ENTRY(pitch_spin),7);
gtk_entry_set_max_length (GTK_ENTRY(speed_spin),7);
gtk_entry_set_max_length (GTK_ENTRY(scale_spin),7);
speed_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,5);
pitch_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,5);
scale_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,5);
opt_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,5);
gtk_container_set_border_width(GTK_CONTAINER(speed_hbox), 3);
gtk_container_set_border_width(GTK_CONTAINER(pitch_hbox), 3);
gtk_container_set_border_width(GTK_CONTAINER(scale_hbox), 3);
gtk_container_set_border_width(GTK_CONTAINER(opt_hbox), 3);
gtk_box_pack_start(GTK_BOX(speed_hbox), speed_spin, FALSE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(speed_hbox), speed_scale, TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(pitch_hbox), pitch_spin, FALSE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(pitch_hbox), pitch_scale, TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(scale_hbox), scale_spin, FALSE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(scale_hbox), scale_scale, TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(opt_hbox), volume_toggle, FALSE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(opt_hbox), overlap_toggle,TRUE, TRUE, 5);
speed_frame = gtk_frame_new(_("Speed"));
pitch_frame = gtk_frame_new(_("Pitch"));
scale_frame = gtk_frame_new(_("Scale"));
opt_frame = gtk_frame_new(_("Options"));
gtk_container_add(GTK_CONTAINER(speed_frame), speed_hbox);
gtk_container_add(GTK_CONTAINER(pitch_frame), pitch_hbox);
gtk_container_add(GTK_CONTAINER(scale_frame), scale_hbox);
gtk_container_add(GTK_CONTAINER(opt_frame), opt_hbox);
gtk_container_set_border_width(GTK_CONTAINER(speed_frame), 5);
gtk_container_set_border_width(GTK_CONTAINER(pitch_frame), 5);
gtk_container_set_border_width(GTK_CONTAINER(scale_frame), 5);
gtk_container_set_border_width(GTK_CONTAINER(opt_frame), 5);
vbox=gtk_box_new(GTK_ORIENTATION_VERTICAL,0);
gtk_box_pack_start(GTK_BOX(vbox), pitch_frame, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), speed_frame, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), scale_frame, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), opt_frame, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), logohbox, FALSE, TRUE, 0);
g_signal_connect (sndstretch_config_dialog, "destroy", (GCallback)
sndstretch_config_destroy_cb, NULL);
gtk_window_set_title(GTK_WINDOW(sndstretch_config_dialog), _("SndStretch - Configuration"));
gtk_container_add(GTK_CONTAINER(sndstretch_config_dialog), vbox);
gtk_widget_grab_default(logobutton);
gtk_widget_show_all(sndstretch_config_dialog);
}
static void
colorsel_water_init (ColorselWater *water)
{
GtkWidget *hbox;
GtkWidget *area;
GtkWidget *frame;
GtkAdjustment *adj;
GtkWidget *scale;
water->pressure_adjust = 1.0;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (GTK_BOX (water), hbox, TRUE, TRUE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
area = gtk_drawing_area_new ();
gtk_container_add (GTK_CONTAINER (frame), area);
g_signal_connect (area, "expose-event",
G_CALLBACK (select_area_expose),
NULL);
/* Event signals */
g_signal_connect (area, "motion-notify-event",
G_CALLBACK (motion_notify_event),
water);
g_signal_connect (area, "button-press-event",
G_CALLBACK (button_press_event),
water);
g_signal_connect (area, "proximity-out-event",
G_CALLBACK (proximity_out_event),
water);
gtk_widget_add_events (area,
GDK_LEAVE_NOTIFY_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_KEY_PRESS_MASK |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_PROXIMITY_OUT_MASK);
/* The following call enables tracking and processing of extension
* events for the drawing area
*/
gtk_widget_set_extension_events (area, GDK_EXTENSION_EVENTS_ALL);
gtk_widget_grab_focus (area);
adj = GTK_ADJUSTMENT (gtk_adjustment_new (200.0 - water->pressure_adjust * 100.0,
0.0, 200.0, 1.0, 1.0, 0.0));
g_signal_connect (adj, "value-changed",
G_CALLBACK (pressure_adjust_update),
water);
scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, adj);
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gimp_help_set_help_data (scale, _("Pressure"), NULL);
gtk_box_pack_start (GTK_BOX (hbox), scale, FALSE, FALSE, 0);
gtk_widget_show_all (hbox);
}
int main(int argc, char **argv) {
struct arguments argument;
struct arguments *pargument = &argument;
//InitOpenAL(); // potential memory leak
source = 0;
pargument->first = 1;
pargument->endless_check = 0;
pargument->continue_count = 0;
pargument->offset = 0;
pargument->elapsed = g_timer_new();
GtkWidget *window, *hpaned, *pause_button, *bitrate_label, *chooser1, *chooser2, *chooser3, *vboxl, *vboxr, *check,
*continue_check, *continue_label, *next_button, *button2, *spin_int, *progressbar, *button_hbox, *continue_hbox;
GtkFileFilter *filter1, *filter2;
gtk_init(&argc, &argv);
//g_remove("list.txt");
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
pargument->adjust = (GtkAdjustment*)gtk_adjustment_new(0, 0, 100, 1, 1, 1);
#if GTK3
progressbar = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, adjust);
#endif
progressbar = gtk_hscale_new(pargument->adjust);
gtk_scale_set_draw_value ((GtkScale*)progressbar, FALSE);
gtk_window_set_title(GTK_WINDOW(window), "lelele player");
pargument->label = gtk_label_new ("");
pargument->title_label = gtk_label_new("");
pargument->album_label = gtk_label_new("");
pargument->artist_label = gtk_label_new("");
gtk_label_set_line_wrap((GtkLabel*)pargument->title_label, TRUE);
gtk_label_set_line_wrap((GtkLabel*)pargument->artist_label, TRUE);
gtk_label_set_line_wrap((GtkLabel*)pargument->album_label, TRUE);
continue_label = gtk_label_new("Number of songs played\n -1 to go endless");
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
gtk_widget_set_size_request(window, 500, 250);
hpaned = gtk_hpaned_new();
spin_int = gtk_spin_button_new_with_range(-1, 10000, 1);
gtk_spin_button_set_value ((GtkSpinButton*)spin_int, 1);
pause_button = gtk_button_new_with_mnemonic("_Play/Pause");
next_button = gtk_button_new_with_mnemonic("Next");
check = gtk_check_button_new_with_label ("Endless mode.");
//continue_check = gtk_check_button_new_with_label("Play this number of songs.");
g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy), NULL);
g_signal_connect (G_OBJECT(pause_button), "clicked", G_CALLBACK(play), pargument);
g_signal_connect (G_OBJECT(next_button), "clicked", G_CALLBACK(next), pargument);
g_signal_connect (G_OBJECT(check), "toggled", G_CALLBACK(check_toggled), pargument);
//g_signal_connect(G_OBJECT(continue_check), "toggled", G_CALLBACK(continue_check_toggled), spin_int);
g_signal_connect(G_OBJECT(spin_int), "value-changed", G_CALLBACK(continue_spin_count), pargument);
g_signal_connect(G_OBJECT(progressbar), "value-changed", G_CALLBACK(slider_changed), pargument);
/* Create two buttons, one to select a folder and one to select a file. */
chooser1 = gtk_file_chooser_button_new ("Chooser a Folder", GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
chooser2 = gtk_file_chooser_button_new ("Chooser a Folder", GTK_FILE_CHOOSER_ACTION_OPEN);
chooser3 = gtk_file_chooser_button_new ("Choose a folder for config (may take some time)", GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
/* Monitor when the selected folder or file are changed. */
g_signal_connect (G_OBJECT (chooser2), "selection_changed", G_CALLBACK (file_changed), pargument);
g_signal_connect (G_OBJECT (chooser1), "selection_changed", G_CALLBACK(folder_changed), pargument);
g_signal_connect (G_OBJECT (chooser3), "selection_changed", G_CALLBACK (config_folder_changed), pargument);
/* Set both file chooser buttons to the location of the user's home directory. */
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser2), g_get_home_dir());
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser1), g_get_home_dir());
/* Provide a filter to show all files and one to shown only 3 types of images. */
filter1 = gtk_file_filter_new ();
filter2 = gtk_file_filter_new ();
gtk_file_filter_set_name (filter1, "Audio Files");
gtk_file_filter_set_name (filter2, "All Files");
gtk_file_filter_add_pattern (filter1, "*.mp3");
gtk_file_filter_add_pattern (filter1, "*.flac");
gtk_file_filter_add_pattern (filter1, "*.aac");
gtk_file_filter_add_pattern (filter2, "*");
/* Add the both filters to the file chooser button that selects files. */
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser2), filter1);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser2), filter2);
//gtk_widget_set_sensitive(spin_int, FALSE);
vboxl = gtk_vbox_new (TRUE, 5);
vboxr = gtk_vbox_new (TRUE, 5);
button_hbox = gtk_hbox_new (TRUE, 5);
continue_hbox= gtk_hbox_new (TRUE, 5);
gtk_box_set_homogeneous(GTK_BOX(vboxr), FALSE);
gtk_box_set_homogeneous(GTK_BOX(continue_hbox), FALSE);
gtk_box_pack_start_defaults (GTK_BOX (vboxl), chooser1);
gtk_box_pack_start_defaults (GTK_BOX (vboxl), chooser2);
// gtk_box_pack_start_defaults (GTK_BOX (vboxl), chooser3);
//gtk_box_pack_start_defaults (GTK_BOX (vboxl), check);
gtk_box_pack_start_defaults (GTK_BOX (vboxl), continue_hbox);
gtk_box_pack_start_defaults (GTK_BOX(continue_hbox), continue_label);
gtk_box_pack_start_defaults (GTK_BOX(continue_hbox), spin_int);
gtk_box_pack_start_defaults (GTK_BOX (vboxl), button_hbox);
gtk_box_pack_start_defaults (GTK_BOX (button_hbox), pause_button);
gtk_box_pack_start_defaults (GTK_BOX(button_hbox), next_button);
gtk_box_pack_start_defaults (GTK_BOX(vboxl), progressbar);
gtk_box_pack_start(GTK_BOX (vboxr), pargument->label, FALSE, FALSE, 1);
gtk_box_pack_start(GTK_BOX (vboxr), pargument->title_label, FALSE, FALSE, 1);
gtk_box_pack_start(GTK_BOX (vboxr), pargument->album_label, FALSE, FALSE, 1);
gtk_box_pack_start(GTK_BOX (vboxr), pargument->artist_label, FALSE, FALSE, 1);
#ifdef GTK3
vboxl = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
vboxr = gtk_vboxr_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (vboxl), chooser1, TRUE, TRUE, 3);
gtk_box_pack_start (GTK_BOX (vboxl), chooser2, TRUE, TRUE, 3);
gtk_box_pack_start (GTK_BOX (vboxl), pause_button, TRUE, TRUE, 3);
gtk_box_pack_start (GTK_BOX(vboxl), next_button, TRUE, TRUE, 3);
gtk_box_pack_start (GTK_BOX (vboxl), pargument->label, TRUE, TRUE, 3);
gtk_box_pack_start (GTK_BOX (vboxl), check, TRUE, TRUE, 3);
gtk_box_pack_start (GTK_BOX(vboxl), continue_check, TRUE, TRUE, 3);
gtk_box_pack_start (GTK_BOX(vboxl), spin_int, TRUE, TRUE, 3);
gtk_box_pack_start (GTK_BOX(vboxl), progressbar, TRUE, TRUE, 3);
gtk_box_pack_start (GTK_BOX (vboxr), pargument->label, TRUE, TRUE, 3);
gtk_box_pack_start_defaults (GTK_BOX (vboxr), pargument->title_label, TRUE, TRUE, 3);
gtk_box_pack_start_defaults (GTK_BOX (vboxr), pargument->album_label, TRUE, TRUE, 3);
gtk_box_pack_start_defaults (GTK_BOX (vboxr), pargument->artist_label, TRUE, TRUE, 3);
#endif
gtk_paned_pack1(GTK_PANED(hpaned), vboxl, FALSE, FALSE);
gtk_paned_pack2(GTK_PANED(hpaned), vboxr, TRUE, FALSE);
gtk_container_add (GTK_CONTAINER (window), hpaned);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
void idou_window_init(iDouWindow *self)
{
GtkWidget *window;
GtkWidget *hbox, *hbox2, *hbox3, *hbox4, *hbox5;
GtkWidget *vbox, *vbox2, *vbox3;
GtkWidget *image;
GdkPixbuf *pixbuf;
window = GTK_WIDGET(self);
gtk_window_set_default_size(GTK_WINDOW(window), 720, 580);
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
gtk_widget_set_name(window, "iDouWindow");
self->shadow_radius = 10;
self->frame_radius = 3;
//self->shadow_padding = self->shadow_radius - self->frame_radius;
//GtkWidget *window_shadow = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
//gtk_alignment_set_padding(GTK_ALIGNMENT(window_shadow), self->shadow_padding, self->shadow_padding, self->shadow_padding, self->shadow_padding);
//g_signal_connect(G_OBJECT(window_shadow), "draw", G_CALLBACK(on_draw_shadow), (gpointer)self);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);
hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
vbox3 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);
hbox3 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
hbox4 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
hbox5 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
GtkWidget *title_bar = idou_titlebar_new();
gtk_box_pack_start(GTK_BOX(vbox), title_bar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox2, FALSE, FALSE, 2);
self->music_name = gtk_label_new(NULL);
self->time_label = gtk_label_new("00:00/00:00");
gtk_box_pack_start(GTK_BOX(hbox3), self->music_name, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox3), self->time_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox3), hbox3, FALSE, FALSE, 0);
self->progress_adjust = gtk_adjustment_new(0, 0, 100, 1, 0, 0);
GtkWidget *time_scale = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, self->progress_adjust);
gtk_scale_set_draw_value(GTK_SCALE(time_scale), FALSE);
g_signal_connect(G_OBJECT(time_scale), "value-changed", G_CALLBACK(on_time_scale_change_value), NULL);
gtk_box_pack_start(GTK_BOX(vbox3), time_scale, FALSE, FALSE, 0);
GtkWidget *lyric_toggle = gtk_check_button_new_with_label("歌词");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lyric_toggle), TRUE);
gtk_box_pack_start(GTK_BOX(hbox4), lyric_toggle, FALSE, FALSE, 0);
GtkWidget *align = gtk_alignment_new(0.3, 0, 0, 0);
GtkWidget *last_btn = itk_button_new();
ITK_BUTTON_SET(last_btn,
RESDIR"image/button/last_normal.png",
RESDIR"image/button/last_hover.png",
RESDIR"image/button/last_press.png",
32, 32);
GtkWidget *play_btn = itk_button_new();
ITK_BUTTON_SET(play_btn,
RESDIR"image/button/play_normal.png",
RESDIR"image/button/play_hover.png",
RESDIR"image/button/play_press.png",
32, 32);
GtkWidget *next_btn = itk_button_new();
ITK_BUTTON_SET(next_btn,
RESDIR"image/button/next_normal.png",
RESDIR"image/button/next_hover.png",
RESDIR"image/button/next_press.png",
32, 32);
g_signal_connect(G_OBJECT(play_btn), "clicked", G_CALLBACK(on_play_event), (gpointer)self);
gtk_box_pack_start(GTK_BOX(hbox2), last_btn, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox2), play_btn, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox2), next_btn, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(align), hbox2);
gtk_box_pack_start(GTK_BOX(hbox4), align, TRUE, FALSE, 0);
self->volume_adjust = gtk_adjustment_new(0, 0, 100, 1, 0, 0);
GtkWidget *volume_scale = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, self->volume_adjust);
gtk_range_set_value(GTK_RANGE(volume_scale), 50);
gtk_widget_set_size_request(volume_scale, 60, 10);
gtk_scale_set_draw_value(GTK_SCALE(volume_scale), FALSE);
gtk_box_pack_end(GTK_BOX(hbox4), volume_scale, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox3), hbox4, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), vbox3, FALSE, FALSE, 3);
GtkWidget *music_manager = idou_music_manager_new();
gtk_box_pack_start(GTK_BOX(vbox2), music_manager, TRUE, TRUE, 2);
GtkWidget *order_btn = itk_button_new();
ITK_BUTTON_SET(order_btn,
RESDIR"image/playmode/order_normal.png",
RESDIR"image/playmode/order_hover.png",
RESDIR"image/playmode/order_press.png",
18, 14);
GtkWidget *loop_btn = itk_button_new();
ITK_BUTTON_SET(loop_btn,
RESDIR"image/playmode/loop_normal.png",
RESDIR"image/playmode/loop_hover.png",
RESDIR"image/playmode/loop_press.png",
18, 14);
GtkWidget *random_btn = itk_button_new();
ITK_BUTTON_SET(random_btn,
RESDIR"image/playmode/random_normal.png",
RESDIR"image/playmode/random_hover.png",
RESDIR"image/playmode/random_press.png",
18, 14);
GtkWidget *single_btn = itk_button_new();
ITK_BUTTON_SET(single_btn,
RESDIR"image/playmode/single_normal.png",
RESDIR"image/playmode/single_hover.png",
RESDIR"image/playmode/single_press.png",
18, 14);
gtk_box_pack_start(GTK_BOX(hbox5), order_btn, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox5), loop_btn, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox5), random_btn, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox5), single_btn, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), hbox5, FALSE, FALSE, 3);
GtkWidget *scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
WebKitWebView *web_view;
web_view = webkit_web_view_new();
/*webkit_web_view_load_uri(web_view, "http://www.baidu.com/");*/
webkit_web_view_load_uri(web_view, "file://"RESDIR"html/index.html");
gtk_container_add(GTK_CONTAINER(scrolled), web_view);
gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
g_signal_connect(G_OBJECT(title_bar), "itk-destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect_after(G_OBJECT(window), "draw", G_CALLBACK(on_draw), NULL);
GtkCssProvider *provider = gtk_css_provider_new();
GdkScreen *screen = gdk_screen_get_default();
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
gtk_widget_set_visual(window, visual);
const gchar *css_data = "#iDouWindow {"
"background-image: url('"
RESDIR"image/skin/blueSky.jpg');"
"background-size: 100% 100%;"
"}";
gtk_css_provider_load_from_data(provider, css_data, -1, NULL);
gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref(provider);
gtk_widget_show_all(window);
}
void
procdialog_create_renice_dialog (ProcData *procdata)
{
ProcInfo *info = procdata->selected_process;
GtkWidget *dialog = NULL;
GtkWidget *dialog_vbox;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *priority_label;
GtkWidget *grid;
GtkAdjustment *renice_adj;
GtkWidget *hscale;
GtkWidget *button;
GtkWidget *icon;
gchar *text;
gchar *dialog_title;
if (renice_dialog)
return;
if (!info)
return;
dialog_title = g_strdup_printf (_("Change Priority of Process “%s” (PID: %u)"),
info->name, info->pid);
dialog = gtk_dialog_new_with_buttons (dialog_title, NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
"gtk-cancel", GTK_RESPONSE_CANCEL,
NULL);
g_free (dialog_title);
renice_dialog = dialog;
gtk_window_set_resizable (GTK_WINDOW (renice_dialog), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (renice_dialog), 5);
button = gtk_button_new_with_mnemonic (_("Change _Priority"));
gtk_widget_set_can_default (button, TRUE);
icon = gtk_image_new_from_stock ("gtk-ok", GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (button), icon);
gtk_dialog_add_action_widget (GTK_DIALOG (renice_dialog), button, 100);
gtk_dialog_set_default_response (GTK_DIALOG (renice_dialog), 100);
new_nice_value = -100;
dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_box_set_spacing (GTK_BOX (dialog_vbox), 2);
gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_box_pack_start (GTK_BOX (dialog_vbox), vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID(grid), 12);
gtk_grid_set_row_spacing (GTK_GRID(grid), 6);
gtk_box_pack_start (GTK_BOX (vbox), grid, TRUE, TRUE, 0);
label = gtk_label_new_with_mnemonic (_("_Nice value:"));
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 2);
renice_adj = gtk_adjustment_new (info->nice, RENICE_VAL_MIN, RENICE_VAL_MAX, 1, 1, 0);
new_nice_value = 0;
hscale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, renice_adj);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), hscale);
gtk_scale_set_digits (GTK_SCALE (hscale), 0);
gtk_widget_set_hexpand (hscale, TRUE);
gtk_grid_attach (GTK_GRID (grid), hscale, 1, 0, 1, 1);
text = g_strdup_printf(_("(%s Priority)"), procman::get_nice_level (info->nice));
priority_label = gtk_label_new (text);
gtk_grid_attach (GTK_GRID (grid), priority_label, 1, 1, 1, 1);
g_free(text);
text = g_strconcat("<small><i><b>", _("Note:"), "</b> ",
_("The priority of a process is given by its nice value. A lower nice value corresponds to a higher priority."),
"</i></small>", NULL);
label = gtk_label_new (_(text));
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
g_free (text);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (renice_dialog_button_pressed), procdata);
g_signal_connect (G_OBJECT (renice_adj), "value_changed",
G_CALLBACK (renice_scale_changed), priority_label);
gtk_widget_show_all (dialog);
}
static gboolean init (void)
{
search_tool = aud_plugin_lookup_basename ("search-tool");
aud_config_set_defaults ("gtkui", gtkui_defaults);
audgui_set_default_icon();
audgui_register_stock_icons();
pw_col_init ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip ((GtkWindow *) window, FALSE);
g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(window_delete), NULL);
accel = gtk_accel_group_new ();
gtk_window_add_accel_group ((GtkWindow *) window, accel);
vbox_outer = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add ((GtkContainer *) window, vbox_outer);
menu_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start ((GtkBox *) vbox_outer, menu_box, FALSE, FALSE, 0);
toolbar = gtk_toolbar_new ();
gtk_toolbar_set_style ((GtkToolbar *) toolbar, GTK_TOOLBAR_ICONS);
GtkStyleContext * context = gtk_widget_get_style_context (toolbar);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
gtk_box_pack_start ((GtkBox *) vbox_outer, toolbar, FALSE, FALSE, 0);
/* search button */
if (search_tool)
{
search_button = toggle_button_new (GTK_STOCK_FIND, NULL, toggle_search_tool);
gtk_toolbar_insert ((GtkToolbar *) toolbar, search_button, -1);
gtk_toggle_tool_button_set_active ((GtkToggleToolButton *) search_button,
aud_plugin_get_enabled (search_tool));
aud_plugin_add_watch (search_tool, search_tool_toggled, NULL);
}
/* playback buttons */
toolbar_button_add (toolbar, button_open_pressed, GTK_STOCK_OPEN);
toolbar_button_add (toolbar, button_add_pressed, GTK_STOCK_ADD);
button_play = toolbar_button_add (toolbar, aud_drct_play_pause, GTK_STOCK_MEDIA_PLAY);
button_stop = toolbar_button_add (toolbar, aud_drct_stop, GTK_STOCK_MEDIA_STOP);
toolbar_button_add (toolbar, aud_drct_pl_prev, GTK_STOCK_MEDIA_PREVIOUS);
toolbar_button_add (toolbar, aud_drct_pl_next, GTK_STOCK_MEDIA_NEXT);
/* time slider and label */
GtkToolItem * boxitem1 = gtk_tool_item_new ();
gtk_tool_item_set_expand (boxitem1, TRUE);
gtk_toolbar_insert ((GtkToolbar *) toolbar, boxitem1, -1);
GtkWidget * box1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add ((GtkContainer *) boxitem1, box1);
slider = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, NULL);
gtk_range_set_increments ((GtkRange *) slider, 5000, 5000);
gtk_scale_set_draw_value(GTK_SCALE(slider), FALSE);
gtk_widget_set_size_request(slider, 120, -1);
gtk_widget_set_valign (slider, GTK_ALIGN_CENTER);
gtk_widget_set_can_focus(slider, FALSE);
gtk_box_pack_start ((GtkBox *) box1, slider, TRUE, TRUE, 6);
label_time = markup_label_new(NULL);
gtk_box_pack_end ((GtkBox *) box1, label_time, FALSE, FALSE, 6);
gtk_widget_set_no_show_all (slider, TRUE);
gtk_widget_set_no_show_all (label_time, TRUE);
/* repeat and shuffle buttons */
button_repeat = toggle_button_new ("media-playlist-repeat", "RP", toggle_repeat);
gtk_toolbar_insert ((GtkToolbar *) toolbar, button_repeat, -1);
button_shuffle = toggle_button_new ("media-playlist-shuffle", "SF", toggle_shuffle);
gtk_toolbar_insert ((GtkToolbar *) toolbar, button_shuffle, -1);
/* volume button */
GtkToolItem * boxitem2 = gtk_tool_item_new ();
gtk_toolbar_insert ((GtkToolbar *) toolbar, boxitem2, -1);
GtkWidget * box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add ((GtkContainer *) boxitem2, box2);
volume = gtk_volume_button_new();
gtk_button_set_relief(GTK_BUTTON(volume), GTK_RELIEF_NONE);
gtk_scale_button_set_adjustment(GTK_SCALE_BUTTON(volume), GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, 100, 1, 5, 0)));
gtk_widget_set_can_focus(volume, FALSE);
gint lvol = 0, rvol = 0;
aud_drct_get_volume(&lvol, &rvol);
gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume), (lvol + rvol) / 2);
gtk_box_pack_start ((GtkBox *) box2, volume, FALSE, FALSE, 0);
/* main UI layout */
layout_load ();
GtkWidget * layout = layout_new ();
gtk_box_pack_start ((GtkBox *) vbox_outer, layout, TRUE, TRUE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
layout_add_center (vbox);
ui_playlist_notebook_new ();
gtk_box_pack_start ((GtkBox *) vbox, (GtkWidget *) UI_PLAYLIST_NOTEBOOK, TRUE, TRUE, 0);
/* optional UI elements */
show_menu (aud_get_bool ("gtkui", "menu_visible"));
show_infoarea (aud_get_bool ("gtkui", "infoarea_visible"));
if (aud_get_bool ("gtkui", "statusbar_visible"))
{
statusbar = ui_statusbar_new ();
gtk_box_pack_end ((GtkBox *) vbox_outer, statusbar, FALSE, FALSE, 0);
}
AUDDBG("hooks associate\n");
ui_hooks_associate();
AUDDBG("playlist associate\n");
ui_playlist_notebook_populate();
g_signal_connect(slider, "change-value", G_CALLBACK(ui_slider_change_value_cb), NULL);
g_signal_connect(slider, "button-press-event", G_CALLBACK(ui_slider_button_press_cb), NULL);
g_signal_connect(slider, "button-release-event", G_CALLBACK(ui_slider_button_release_cb), NULL);
volume_change_handler_id = g_signal_connect(volume, "value-changed", G_CALLBACK(ui_volume_value_changed_cb), NULL);
g_signal_connect(volume, "pressed", G_CALLBACK(ui_volume_pressed_cb), NULL);
g_signal_connect(volume, "released", G_CALLBACK(ui_volume_released_cb), NULL);
update_volume_timeout_source = g_timeout_add(250, (GSourceFunc) ui_volume_slider_update, volume);
g_signal_connect (window, "map-event", (GCallback) window_mapped_cb, NULL);
g_signal_connect (window, "key-press-event", (GCallback) window_keypress_cb, NULL);
g_signal_connect (UI_PLAYLIST_NOTEBOOK, "key-press-event", (GCallback) playlist_keypress_cb, NULL);
if (aud_drct_get_playing ())
{
ui_playback_begin ();
if (aud_drct_get_ready ())
ui_playback_ready ();
}
else
ui_playback_stop ();
title_change_cb ();
gtk_widget_show_all (vbox_outer);
update_toggles (NULL, NULL);
menu_rclick = make_menu_rclick (accel);
menu_tab = make_menu_tab (accel);
return TRUE;
}
//===================================================================
MemObj GUI_Slider__ (MemObj *o_par, int typ, void *funcnam,
double valMin, double valMax, double valStart,
char *opts) {
//===================================================================
/// \code
/// GUI_Slider__ Slider = AdjustmentControl
///
/// Input:
/// parent parentBox
/// typ 0=horizontal, 1=vertical.
/// funcnam callBack-function for moving the slider; NULL = no callback.
/// opts options; (HorSiz,VertSiz)
/// HorSiz,VertSiz: size in characters; default is automatic size.
/// 'e' = expand widget; default is fixed size.
/// Examples: "" or "10" or "10e,e"
/// "10e,e" horiz. size 10 chars, hor. and vert. expandable.
///
/// funcnam prototyp:
/// int funcnam (MemObj *mo, void **data);
/// // data=table of 2 pointers;
/// GUI_DATA_EVENT = *(int*)data[0] = TYP_EventMove or
/// TYP_EventPress (left mousebutton)
/// TYP_EventRelease
/// GUI_DATA_D1 = *(double*)data[1] = slider-value (only TYP_EventMove)
/// GUI_OBJ_TYP(mo) = TYP_GUI_Slider
///
/// Example without callback:
/// wsl1 = GUI_Slider__ (&box1, 0, NULL, 0., 1., 0.5, "8");
/// // query slider-value
/// printf(" sliVal=%f\n",GUI_Slider_get(&wsl1));
/// // change slider-value
/// GUI_Slider_set (&wsl1, 0.75);
///
/// Example with callback:
/// wsl1 = GUI_Slider__ (&box1, 0, sl_CB, 0., 1., 0.5, "8");
/// int sl_CB (MemObj *mo, void **data) {
/// if(GUI_DATA_EVENT == TYP_EventMove) {
/// printf("sl_CB %lf\n",GUI_DATA_D1); // slider-value as double
/// }
/// }
/// \endcode
int pTyp;
GtkAdjustment *adj1;
// GtkObject *adj1;
GtkWidget *wsc1;
void *w_par;
double d1;
Obj_Slider *go;
// get gtk-widget for parentBox from MemObj
w_par = GUI_obj_parent__ (&pTyp, o_par);
if(!w_par) return (UME_obj_invalid_set (-3));
// get address & memspc
GUI_obj_spc ((void**)&go, sizeof(Obj_Slider));
if(!go) return (UME_obj_invalid_set (-1));
// Adjustment (StartVal minVal maxVal incr pageIncr pageSize)
d1 = (valMax - valMin ) / 100.;
adj1 = gtk_adjustment_new((gdouble)valStart,
(gdouble)valMin,
(gdouble)valMax,
(gdouble)d1,
(gdouble)0.,
(gdouble)0.);
// callback for moving the control
if(funcnam) {
g_signal_connect (adj1, "value_changed",
G_CALLBACK(GUI_Slider_cb1),
PTR_MEMOBJ(go->mem_obj));
}
wsc1 = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(adj1));
if(funcnam) { // 2013-09-09
gtk_widget_add_events (GTK_WIDGET(wsc1),
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK);
g_signal_connect (G_OBJECT(wsc1), "button_press_event",
G_CALLBACK(GUI_Slider_cb2),
PTR_MEMOBJ(go->mem_obj));
g_signal_connect (G_OBJECT(wsc1), "button_release_event",
G_CALLBACK(GUI_Slider_cb2),
PTR_MEMOBJ(go->mem_obj));
}
UI_act_wi = wsc1; // GUI_Tip; 2013-09-09
// do not display actual value
gtk_scale_set_draw_value (GTK_SCALE(wsc1), FALSE);
// // GUI_packwn (w_par, wsc1, siz, 0);
// if(siz == 1) GUI_packwn (w_par, wsc1, 0, 1);
// else GUI_packwn (w_par, wsc1, siz, 0);
GUI_w_pack1 (pTyp, w_par, wsc1, opts);
// fill obj
go->gio_typ = TYP_GUI_Slider;
go->slider = adj1; //wsc1;
go->uFunc = funcnam;
return (((Obj_Unknown*)go)->mem_obj);
}
static void
create_scale_box (GvcBalanceBar *bar)
{
#if GTK_CHECK_VERSION (3, 0, 0)
bar->priv->scale_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
bar->priv->start_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
bar->priv->end_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
bar->priv->scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL,
bar->priv->adjustment);
#if GTK_CHECK_VERSION (3, 4, 0)
/* Balance and fade scales do not have an origin */
if (bar->priv->btype != BALANCE_TYPE_LFE)
gtk_scale_set_has_origin (GTK_SCALE (bar->priv->scale), FALSE);
#endif
#else
bar->priv->scale_box = gtk_hbox_new (FALSE, 6);
bar->priv->start_box = gtk_hbox_new (FALSE, 6);
bar->priv->end_box = gtk_hbox_new (FALSE, 6);
bar->priv->scale = gtk_hscale_new (bar->priv->adjustment);
/* GTK2 way to remove the origin */
if (bar->priv->btype != BALANCE_TYPE_LFE) {
gtk_rc_parse_string (BALANCE_BAR_STYLE);
gtk_widget_set_name (bar->priv->scale, "balance-bar-scale");
}
#endif
gtk_widget_set_size_request (bar->priv->scale, SCALE_SIZE, -1);
gtk_box_pack_start (GTK_BOX (bar->priv->scale_box),
bar->priv->start_box,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (bar->priv->start_box),
bar->priv->label,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (bar->priv->scale_box),
bar->priv->scale,
TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (bar->priv->scale_box),
bar->priv->end_box,
FALSE, FALSE, 0);
ca_gtk_widget_disable_sounds (bar->priv->scale, FALSE);
gtk_widget_add_events (bar->priv->scale, GDK_SCROLL_MASK);
g_signal_connect (G_OBJECT (bar->priv->scale),
"scroll-event",
G_CALLBACK (on_scale_scroll_event),
bar);
if (bar->priv->size_group != NULL) {
gtk_size_group_add_widget (bar->priv->size_group,
bar->priv->start_box);
if (bar->priv->symmetric)
gtk_size_group_add_widget (bar->priv->size_group,
bar->priv->end_box);
}
gtk_scale_set_draw_value (GTK_SCALE (bar->priv->scale), FALSE);
}
/**
* bt_volume_popup_new:
* @adj: the adjustment for the popup
*
* Create a new instance
*
* Returns: the new instance or %NULL in case of an error
*/
GtkWidget *
bt_volume_popup_new (GtkAdjustment * adj)
{
GtkWidget *box, *scale, *frame, *label;
BtVolumePopup *self = g_object_new (BT_TYPE_VOLUME_POPUP,
"can-focus", TRUE,
"type", GTK_WINDOW_POPUP,
NULL);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box),
gtk_separator_new (GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, adj);
self->scale = GTK_RANGE (scale);
gtk_widget_set_size_request (scale, -1, 200);
// FIXME(ensonic): workaround for https://bugzilla.gnome.org/show_bug.cgi?id=667598
//gtk_range_set_inverted(self->scale, TRUE);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
#if 0
gtk_scale_add_mark (GTK_SCALE (scale), 0.0, GTK_POS_LEFT,
"<small>0 %</small>");
gtk_scale_add_mark (GTK_SCALE (scale), 25.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 50.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 75.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 100.0, GTK_POS_LEFT,
"<small>100 %</small>");
gtk_scale_add_mark (GTK_SCALE (scale), 150.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 200.0, GTK_POS_LEFT,
"<small>200 %</small>");
gtk_scale_add_mark (GTK_SCALE (scale), 250.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 300.0, GTK_POS_LEFT,
"<small>300 %</small>");
gtk_scale_add_mark (GTK_SCALE (scale), 350.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 400.0, GTK_POS_LEFT,
"<small>400 %</small>");
#else
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 0.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 25.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 50.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 75.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 100.0, GTK_POS_LEFT,
"<small>100 %</small>");
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 150.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 200.0, GTK_POS_LEFT,
"<small>200 %</small>");
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 250.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 300.0, GTK_POS_LEFT,
"<small>300 %</small>");
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 350.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 400.0, GTK_POS_LEFT,
"<small>400 %</small>");
#endif
g_signal_connect (self->scale, "value-changed", G_CALLBACK (cb_scale_changed),
label);
cb_scale_changed (self->scale, label);
gtk_box_pack_start (GTK_BOX (box), scale, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (frame), box);
gtk_container_add (GTK_CONTAINER (self), frame);
gtk_widget_show_all (frame);
g_signal_connect (self, "button-press-event", G_CALLBACK (cb_dock_press),
self);
return GTK_WIDGET (self);
}
gboolean show_mixer(GtkWidget *widget, GdkEvent *event, gpointer user_data)
{
GtkWidget *win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(win), "SIDE Mixer");
gtk_container_set_border_width(GTK_CONTAINER(win), 10);
gtk_window_resize(GTK_WINDOW(win), 150, 300);
GdkScreen *screen = gdk_screen_get_default();
fwin = win;
g_timeout_add(100, check_focus, win);
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
GtkWidget *dsc = gtk_label_new("master");
GtkAdjustment *adj = gtk_adjustment_new(50, 0, 100, 5, 0, 0);
g_signal_connect(G_OBJECT(adj), "value-changed", G_CALLBACK(set_volume), NULL);
GtkWidget *scl = gtk_scale_new(GTK_ORIENTATION_VERTICAL, adj);
gtk_scale_set_draw_value(GTK_SCALE(scl), FALSE);
s_mute = gtk_toggle_button_new_with_label("mute");
g_signal_connect(G_OBJECT(s_mute), "toggled", G_CALLBACK(set_mute), (gpointer) adj);
gtk_box_pack_end(GTK_BOX(box), s_mute, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(box), dsc);
gtk_box_pack_end(GTK_BOX(box), scl, TRUE, TRUE, 5);
int x, y;
gtk_window_get_size(GTK_WINDOW(win), &x, &y);
gtk_window_set_decorated(GTK_WINDOW(win), FALSE);
gtk_window_move(GTK_WINDOW(win), gdk_screen_get_width(screen), gdk_screen_get_height(screen) - (y+25));
gtk_container_add(GTK_CONTAINER(win), box);
gtk_widget_show_all(win);
snd_mixer_t *mix;
snd_mixer_selem_id_t *sid;
const char *card = "default";
const char *selem_name = "Master";
long val, max, min;
snd_mixer_open(&mix, 0);
snd_mixer_attach(mix, card);
snd_mixer_selem_register(mix, NULL, NULL);
snd_mixer_load(mix);
snd_mixer_selem_id_alloca(&sid);
snd_mixer_selem_id_set_index(sid, 0);
snd_mixer_selem_id_set_name(sid, selem_name);
snd_mixer_elem_t* elem = snd_mixer_find_selem(mix, sid);
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_MONO , &val);
gtk_adjustment_set_value(adj, 100 - (int) 100 * val / max);
snd_mixer_close(mix);
return FALSE;
}
static GtkWidget *
gimp_navigation_editor_new_private (GimpMenuFactory *menu_factory,
GimpDisplayShell *shell)
{
GimpNavigationEditor *editor;
g_return_val_if_fail (menu_factory == NULL ||
GIMP_IS_MENU_FACTORY (menu_factory), NULL);
g_return_val_if_fail (shell == NULL || GIMP_IS_DISPLAY_SHELL (shell), NULL);
g_return_val_if_fail (menu_factory || shell, NULL);
if (shell)
{
Gimp *gimp = shell->display->gimp;
GimpDisplayConfig *config = shell->display->config;
GimpView *view;
editor = g_object_new (GIMP_TYPE_NAVIGATION_EDITOR, NULL);
view = GIMP_VIEW (editor->view);
gimp_view_renderer_set_size (view->renderer,
config->nav_preview_size * 3,
view->renderer->border_width);
gimp_view_renderer_set_context (view->renderer,
gimp_get_user_context (gimp));
gimp_navigation_editor_set_shell (editor, shell);
}
else
{
GtkWidget *hscale;
GtkWidget *hbox;
editor = g_object_new (GIMP_TYPE_NAVIGATION_EDITOR,
"menu-factory", menu_factory,
"menu-identifier", "<NavigationEditor>",
NULL);
gtk_widget_set_size_request (editor->view,
GIMP_VIEW_SIZE_HUGE,
GIMP_VIEW_SIZE_HUGE);
gimp_view_set_expand (GIMP_VIEW (editor->view), TRUE);
/* the editor buttons */
editor->zoom_out_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor), "view",
"view-zoom-out", NULL);
editor->zoom_in_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor), "view",
"view-zoom-in", NULL);
editor->zoom_100_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor), "view",
"view-zoom-1-1", NULL);
editor->zoom_fit_in_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor), "view",
"view-zoom-fit-in", NULL);
editor->zoom_fill_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor), "view",
"view-zoom-fill", NULL);
editor->shrink_wrap_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor), "view",
"view-shrink-wrap", NULL);
/* the zoom scale */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_end (GTK_BOX (editor), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
editor->zoom_adjustment =
GTK_ADJUSTMENT (gtk_adjustment_new (0.0, -8.0, 8.0, 0.5, 1.0, 0.0));
g_signal_connect (editor->zoom_adjustment, "value-changed",
G_CALLBACK (gimp_navigation_editor_zoom_adj_changed),
editor);
hscale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL,
editor->zoom_adjustment);
gtk_scale_set_draw_value (GTK_SCALE (hscale), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), hscale, TRUE, TRUE, 0);
gtk_widget_show (hscale);
/* the zoom label */
editor->zoom_label = gtk_label_new ("100%");
gtk_label_set_width_chars (GTK_LABEL (editor->zoom_label), 7);
gtk_box_pack_start (GTK_BOX (hbox), editor->zoom_label, FALSE, FALSE, 0);
gtk_widget_show (editor->zoom_label);
}
gimp_view_renderer_set_background (GIMP_VIEW (editor->view)->renderer,
GIMP_STOCK_TEXTURE);
return GTK_WIDGET (editor);
}
static GtkObject *
gimp_scale_entry_new_internal (gboolean color_scale,
GtkTable *table,
gint column,
gint row,
const gchar *text,
gint scale_width,
gint spinbutton_width,
gdouble value,
gdouble lower,
gdouble upper,
gdouble step_increment,
gdouble page_increment,
guint digits,
gboolean constrain,
gdouble unconstrained_lower,
gdouble unconstrained_upper,
const gchar *tooltip,
const gchar *help_id)
{
GtkWidget *label;
GtkWidget *scale;
GtkWidget *spinbutton;
GtkObject *adjustment;
GtkObject *return_adj;
label = gtk_label_new_with_mnemonic (text);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
column, column + 1, row, row + 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
if (! constrain &&
unconstrained_lower <= lower &&
unconstrained_upper >= upper)
{
GtkObject *constrained_adj;
constrained_adj = gtk_adjustment_new (value, lower, upper,
step_increment, page_increment,
0.0);
spinbutton = gimp_spin_button_new (&adjustment, value,
unconstrained_lower,
unconstrained_upper,
step_increment, page_increment, 0.0,
1.0, digits);
g_signal_connect
(G_OBJECT (constrained_adj), "value-changed",
G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback),
adjustment);
g_signal_connect
(G_OBJECT (adjustment), "value-changed",
G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback),
constrained_adj);
return_adj = adjustment;
adjustment = constrained_adj;
}
else
{
spinbutton = gimp_spin_button_new (&adjustment, value, lower, upper,
step_increment, page_increment, 0.0,
1.0, digits);
return_adj = adjustment;
}
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
if (spinbutton_width > 0)
{
if (spinbutton_width < 17)
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), spinbutton_width);
else
gtk_widget_set_size_request (spinbutton, spinbutton_width, -1);
}
if (color_scale)
{
scale = gimp_color_scale_new (GTK_ORIENTATION_HORIZONTAL,
GIMP_COLOR_SELECTOR_VALUE);
gtk_range_set_adjustment (GTK_RANGE (scale),
GTK_ADJUSTMENT (adjustment));
}
else
{
scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL,
GTK_ADJUSTMENT (adjustment));
}
if (scale_width > 0)
gtk_widget_set_size_request (scale, scale_width, -1);
gtk_scale_set_digits (GTK_SCALE (scale), digits);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_table_attach (GTK_TABLE (table), scale,
column + 1, column + 2, row, row + 1,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_show (scale);
gtk_table_attach (GTK_TABLE (table), spinbutton,
column + 2, column + 3, row, row + 1,
GTK_FILL | GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_widget_show (spinbutton);
if (tooltip || help_id)
{
gimp_help_set_help_data (label, tooltip, help_id);
gimp_help_set_help_data (scale, tooltip, help_id);
gimp_help_set_help_data (spinbutton, tooltip, help_id);
}
g_object_set_data (G_OBJECT (return_adj), "label", label);
g_object_set_data (G_OBJECT (return_adj), "scale", scale);
g_object_set_data (G_OBJECT (return_adj), "spinbutton", spinbutton);
return return_adj;
}
/*
* attach v4l2 controls tab widget
* args:
* parent - tab parent widget
*
* asserts:
* parent is not null
*
* returns: error code (0 -OK)
*/
int gui_attach_gtk3_v4l2ctrls(GtkWidget *parent)
{
/*assertions*/
assert(parent != NULL);
if(debug_level > 1)
printf("GUVCVIEW: attaching v4l2 controls\n");
GtkWidget *img_controls_grid = gtk_grid_new();
gtk_widget_show (img_controls_grid);
gtk_grid_set_column_homogeneous (GTK_GRID(img_controls_grid), FALSE);
gtk_widget_set_hexpand (img_controls_grid, TRUE);
gtk_widget_set_halign (img_controls_grid, GTK_ALIGN_FILL);
gtk_grid_set_row_spacing (GTK_GRID(img_controls_grid), 4);
gtk_grid_set_column_spacing (GTK_GRID (img_controls_grid), 4);
gtk_container_set_border_width (GTK_CONTAINER (img_controls_grid), 2);
int i = 0;
int n = 0;
v4l2_ctrl_t *current = v4l2core_get_control_list();
for(; current != NULL; current = current->next, ++n)
{
if(current == NULL)
{
fprintf(stderr, "GUVCVIEW: ERROR (attach gtk3 controls) empty control in list\n");
break;
}
if(!is_control_panel &&
(current->control.id == V4L2_CID_FOCUS_LOGITECH ||
current->control.id == V4L2_CID_FOCUS_ABSOLUTE))
{
++n; /*add a virtual software autofocus control*/
}
widget_list_size = n + 1;
control_widgets_list = realloc(control_widgets_list, sizeof(control_widgets_t) * widget_list_size);
if(control_widgets_list == NULL)
{
fprintf(stderr,"GUVCVIEW: FATAL memory allocation failure (gui_attach_gtk3_v4l2ctrls): %s\n", strerror(errno));
exit(-1);
}
/*label*/
char *tmp;
tmp = g_strdup_printf ("%s:", current->name);
control_widgets_list[widget_list_size - 1].label = gtk_label_new (tmp);
g_free(tmp);
gtk_widget_show (control_widgets_list[widget_list_size - 1].label);
#if GTK_VER_AT_LEAST(3,15)
gtk_label_set_xalign(GTK_LABEL(control_widgets_list[widget_list_size - 1].label), 1);
gtk_label_set_yalign(GTK_LABEL(control_widgets_list[widget_list_size - 1].label), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (control_widgets_list[widget_list_size - 1].label), 1, 0.5);
#endif
control_widgets_list[widget_list_size - 1].id = current->control.id;
control_widgets_list[widget_list_size - 1].widget = NULL;
control_widgets_list[widget_list_size - 1].widget2 = NULL; /*usually a spin button*/
switch (current->control.type)
{
case V4L2_CTRL_TYPE_INTEGER:
switch (current->control.id)
{
//special cases
case V4L2_CID_PAN_RELATIVE:
case V4L2_CID_TILT_RELATIVE:
{
control_widgets_list[n].widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1);
GtkWidget *PanTilt1 = NULL;
GtkWidget *PanTilt2 = NULL;
if(current->control.id == V4L2_CID_PAN_RELATIVE)
{
PanTilt1 = gtk_button_new_with_label(_("Left"));
PanTilt2 = gtk_button_new_with_label(_("Right"));
}
else
{
PanTilt1 = gtk_button_new_with_label(_("Down"));
PanTilt2 = gtk_button_new_with_label(_("Up"));
}
gtk_widget_show (PanTilt1);
gtk_widget_show (PanTilt2);
gtk_box_pack_start(GTK_BOX(control_widgets_list[n].widget),PanTilt1,TRUE,TRUE,2);
gtk_box_pack_start(GTK_BOX(control_widgets_list[n].widget),PanTilt2,TRUE,TRUE,2);
g_object_set_data (G_OBJECT (PanTilt1), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (PanTilt2), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signals*/
g_signal_connect (GTK_BUTTON(PanTilt1), "clicked",
G_CALLBACK (button_PanTilt1_clicked), NULL);
g_signal_connect (GTK_BUTTON(PanTilt2), "clicked",
G_CALLBACK (button_PanTilt2_clicked), NULL);
gtk_widget_show (control_widgets_list[n].widget);
control_widgets_list[n].widget2 = gtk_spin_button_new_with_range(-256, 256, 64);
gtk_editable_set_editable(GTK_EDITABLE(control_widgets_list[n].widget2), TRUE);
if(current->control.id == V4L2_CID_PAN_RELATIVE)
gtk_spin_button_set_value (GTK_SPIN_BUTTON(control_widgets_list[n].widget2), v4l2core_get_pan_step());
else
gtk_spin_button_set_value (GTK_SPIN_BUTTON(control_widgets_list[n].widget2),v4l2core_get_tilt_step());
/*connect signal*/
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
g_signal_connect(GTK_SPIN_BUTTON(control_widgets_list[n].widget2),"value-changed",
G_CALLBACK (pan_tilt_step_changed), NULL);
gtk_widget_show (control_widgets_list[n].widget2);
break;
}
case V4L2_CID_PAN_RESET:
case V4L2_CID_TILT_RESET:
{
control_widgets_list[n].widget = gtk_button_new_with_label(" ");
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget), "clicked",
G_CALLBACK (button_clicked), NULL);
break;
};
case V4L2_CID_LED1_MODE_LOGITECH:
{
char* LEDMenu[4] = {_("Off"),_("On"),_("Blinking"),_("Auto")};
/*turn it into a menu control*/
if(!current->menu)
current->menu = calloc(4+1, sizeof(struct v4l2_querymenu));
else
current->menu = realloc(current->menu, (4+1) * sizeof(struct v4l2_querymenu));
if(current->menu == NULL)
{
fprintf(stderr,"GUVCVIEW: FATAL memory allocation failure (gui_attach_gtk3_v4l2ctrls): %s\n", strerror(errno));
exit(-1);
}
current->menu[0].id = current->control.id;
current->menu[0].index = 0;
current->menu[0].name[0] = 'N'; /*just set something here*/
current->menu[1].id = current->control.id;
current->menu[1].index = 1;
current->menu[1].name[0] = 'O';
current->menu[2].id = current->control.id;
current->menu[2].index = 2;
current->menu[2].name[0] = 'B';
current->menu[3].id = current->control.id;
current->menu[3].index = 3;
current->menu[3].name[0] = 'A';
current->menu[4].id = current->control.id;
current->menu[4].index = current->control.maximum+1;
current->menu[4].name[0] = '\0';
int j = 0;
int def = 0;
control_widgets_list[n].widget = gtk_combo_box_text_new ();
for (j = 0; current->menu[j].index <= current->control.maximum; j++)
{
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget),
(char *) LEDMenu[j]);
if(current->value == current->menu[j].index)
def = j;
}
gtk_combo_box_set_active (GTK_COMBO_BOX(control_widgets_list[n].widget), def);
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget), "changed",
G_CALLBACK (combo_changed), NULL);
break;
}
case V4L2_CID_RAW_BITS_PER_PIXEL_LOGITECH:
{
/*turn it into a menu control*/
char* BITSMenu[2] = {_("8 bit"),_("12 bit")};
/*turn it into a menu control*/
if(!current->menu)
current->menu = calloc(2+1, sizeof(struct v4l2_querymenu));
else
current->menu = realloc(current->menu, (2+1) * sizeof(struct v4l2_querymenu));
if(current->menu == NULL)
{
fprintf(stderr,"GUVCVIEW: FATAL memory allocation failure (gui_attach_gtk3_v4l2ctrls): %s\n", strerror(errno));
exit(-1);
}
current->menu[0].id = current->control.id;
current->menu[0].index = 0;
current->menu[0].name[0] = 'o'; /*just set something here*/
current->menu[1].id = current->control.id;
current->menu[1].index = 1;
current->menu[1].name[0] = 'd';
current->menu[2].id = current->control.id;
current->menu[2].index = 2;
current->menu[2].name[0] = '\0';
int j = 0;
int def = 0;
control_widgets_list[n].widget = gtk_combo_box_text_new ();
for (j = 0; current->menu[j].index <= current->control.maximum; j++)
{
//if (debug_level > 0)
// printf("GUVCVIEW: adding menu entry %d: %d, %s\n",j, current->menu[j].index, current->menu[j].name);
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget),
(char *) BITSMenu[j]);
if(current->value == current->menu[j].index)
def = j;
}
gtk_combo_box_set_active (GTK_COMBO_BOX(control_widgets_list[n].widget), def);
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget), "changed",
G_CALLBACK (combo_changed), NULL);
break;
}
case V4L2_CID_FOCUS_LOGITECH:
case V4L2_CID_FOCUS_ABSOLUTE:
if(!is_control_panel)
{
/*add a virtual control for software autofocus*/
control_widgets_list[n-1].widget = gtk_check_button_new_with_label (_("Auto Focus (continuous)"));
control_widgets_list[n-1].widget2 = gtk_button_new_with_label (_("set Focus"));
gtk_widget_show (control_widgets_list[n-1].widget);
gtk_widget_show (control_widgets_list[n-1].widget2);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (control_widgets_list[n-1].widget), FALSE);
g_signal_connect (G_OBJECT (control_widgets_list[n-1].widget), "toggled",
G_CALLBACK (autofocus_changed), NULL);
g_signal_connect (G_OBJECT (control_widgets_list[n-1].widget2), "clicked",
G_CALLBACK (setfocus_clicked), NULL);
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n-1].widget, 1, i, 1 , 1);
gtk_widget_set_halign (control_widgets_list[n-1].widget, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (control_widgets_list[n-1].widget, TRUE);
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n-1].widget2, 2, i, 1 , 1);
i++;
}
default: /*standard case - hscale + spin*/
{
/* check for valid range */
if((current->control.maximum > current->control.minimum) && (current->control.step != 0))
{
GtkAdjustment *adjustment = gtk_adjustment_new (
current->value,
current->control.minimum,
current->control.maximum,
current->control.step,
current->control.step*10,
0);
control_widgets_list[n].widget = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adjustment);
gtk_scale_set_draw_value (GTK_SCALE (control_widgets_list[n].widget), FALSE);
gtk_scale_set_digits(GTK_SCALE(control_widgets_list[n].widget), 0);
gtk_widget_show (control_widgets_list[n].widget);
control_widgets_list[n].widget2= gtk_spin_button_new(adjustment, current->control.step, 0);
gtk_editable_set_editable(GTK_EDITABLE(control_widgets_list[n].widget2),TRUE);
gtk_widget_show (control_widgets_list[n].widget2);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
if(!is_control_panel &&
(current->control.id == V4L2_CID_FOCUS_LOGITECH ||
current->control.id == V4L2_CID_FOCUS_ABSOLUTE))
{
g_object_set_data (G_OBJECT (control_widgets_list[n-1].widget), "control_entry",
control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n-1].widget), "control2_entry",
control_widgets_list[n].widget2);
}
/*connect signals*/
g_signal_connect (GTK_SCALE(control_widgets_list[n].widget), "value-changed",
G_CALLBACK (slider_changed), NULL);
g_signal_connect(GTK_SPIN_BUTTON(control_widgets_list[n].widget2),"value-changed",
G_CALLBACK (spin_changed), NULL);
}
else
fprintf(stderr, "GUVCVIEW: (Invalid range) [MAX <= MIN] for control id: 0x%08x \n", current->control.id);
break;
}
}
break;
#ifdef V4L2_CTRL_TYPE_INTEGER64
case V4L2_CTRL_TYPE_INTEGER64:
widget = gtk_entry_new();
gtk_entry_set_max_length(control_widgets_list[n].widget, current->control.maximum);
//control_widgets_list[n].widget2 = gtk_button_new_from_stock(GTK_STOCK_APPLY);
control_widgets_list[n].widget2 = gtk_button_new_with_mnemonic (_("_Apply"));
gtk_widget_show (control_widgets_list[n].widget);
gtk_widget_show (control_widgets_list[n].widget2);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_entry",
widget);
/*connect signal*/
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget2), "clicked",
G_CALLBACK (int64_button_clicked), NULL);
break;
#endif
#ifdef V4L2_CTRL_TYPE_STRING
case V4L2_CTRL_TYPE_STRING:
control_widgets_list[n].widget = gtk_entry_new();
gtk_entry_set_max_length(control_widgets_list[n].widget, current->control.maximum);
//control_widgets_list[n].widget2= gtk_button_new_from_stock(GTK_STOCK_APPLY);
control_widgets_list[n].widget2 = gtk_button_new_with_mnemonic (_("_Apply"));
gtk_widget_show (control_widgets_list[n].widget);
gtk_widget_show (control_widgets_list[n].widget2);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_entry",
widget);
/*connect signal*/
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget2), "clicked",
G_CALLBACK (string_button_clicked), NULL);
break;
#endif
#ifdef V4L2_CTRL_TYPE_BITMASK
case V4L2_CTRL_TYPE_BITMASK:
control_widgets_list[n].widget = gtk_entry_new();
//control_widgets_list[n].widget2 = gtk_button_new_from_stock(GTK_STOCK_APPLY);
control_widgets_list[n].widget2 = gtk_button_new_with_mnemonic (_("_Apply"));
gtk_widget_show (control_widgets_list[n].widget);
gtk_widget_show (control_widgets_list[n].widget2);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_entry",
widget);
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget2), "clicked",
G_CALLBACK (bitmask_button_clicked), NULL);
break;
#endif
#ifdef V4L2_CTRL_TYPE_INTEGER_MENU
case V4L2_CTRL_TYPE_INTEGER_MENU:
#endif
case V4L2_CTRL_TYPE_MENU:
if(current->menu)
{
int j = 0;
int def = 0;
control_widgets_list[n].widget = gtk_combo_box_text_new ();
for (j = 0; current->menu[j].index <= current->control.maximum; j++)
{
if(current->control.type == V4L2_CTRL_TYPE_MENU)
{
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget),
(char *) current->menu_entry[j]);
}
#ifdef V4L2_CTRL_TYPE_INTEGER_MENU
else
{
char buffer[30]="0";
snprintf(buffer, "%" PRIu64 "", 29, current->menu[j].value);
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget), buffer);
}
#endif
if(current->value == current->menu[j].index)
def = j;
}
gtk_combo_box_set_active (GTK_COMBO_BOX(control_widgets_list[n].widget), def);
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget), "changed",
G_CALLBACK (combo_changed), NULL);
}
break;
case V4L2_CTRL_TYPE_BUTTON:
control_widgets_list[n].widget = gtk_button_new_with_label(" ");
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget), "clicked",
G_CALLBACK (button_clicked), NULL);
break;
case V4L2_CTRL_TYPE_BOOLEAN:
if(current->control.id ==V4L2_CID_DISABLE_PROCESSING_LOGITECH)
{
control_widgets_list[n].widget2 = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget2),
"GBGB... | RGRG...");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget2),
"GRGR... | BGBG...");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget2),
"BGBG... | GRGR...");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget2),
"RGRG... | GBGB...");
v4l2core_set_bayer_pix_order(0);
gtk_combo_box_set_active(GTK_COMBO_BOX(control_widgets_list[n].widget2), v4l2core_get_bayer_pix_order());
gtk_widget_show (control_widgets_list[n].widget2);
/*connect signal*/
g_signal_connect (GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget2), "changed",
G_CALLBACK (bayer_pix_ord_changed), NULL);
uint8_t isbayer = (current->value ? TRUE : FALSE);
v4l2core_set_isbayer(isbayer);
}
control_widgets_list[n].widget = gtk_check_button_new();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (control_widgets_list[n].widget),
current->value ? TRUE : FALSE);
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_TOGGLE_BUTTON(control_widgets_list[n].widget), "toggled",
G_CALLBACK (check_changed), NULL);
break;
default:
printf("control[%d]:(unknown - 0x%x) 0x%x '%s'\n",i ,current->control.type,
current->control.id, current->control.name);
break;
}
/*attach widgets to grid*/
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n].label, 0, i, 1 , 1);
if(control_widgets_list[n].widget)
{
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n].widget, 1, i, 1 , 1);
gtk_widget_set_halign (control_widgets_list[n].widget, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (control_widgets_list[n].widget, TRUE);
}
if(control_widgets_list[n].widget2)
{
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n].widget2, 2, i, 1 , 1);
}
i++;
}
/*add control grid to parent container*/
gtk_container_add(GTK_CONTAINER(parent), img_controls_grid);
gui_gtk3_update_controls_state();
return 0;
}
GtkWidget *
scale_create_widget (GtkWidget * dlg)
{
GtkWidget *w;
GtkAdjustment *adj;
gint page;
if (options.scale_data.min_value >= options.scale_data.max_value)
{
g_printerr (_("Maximum value must be greater than minimum value.\n"));
return NULL;
}
/* check for initial value */
if (options.scale_data.have_value)
{
if (options.scale_data.value < options.scale_data.min_value)
{
g_printerr (_("Initial value less than minimal.\n"));
options.scale_data.value = options.scale_data.min_value;
}
else if (options.scale_data.value > options.scale_data.max_value)
{
g_printerr (_("Initial value greater than maximum.\n"));
options.scale_data.value = options.scale_data.max_value;
}
}
else
options.scale_data.value = options.scale_data.min_value;
page = options.scale_data.page == -1 ? options.scale_data.step * 10 : options.scale_data.page;
/* this type conversion needs only for gtk-2.0 */
adj = (GtkAdjustment *) gtk_adjustment_new ((double) options.scale_data.value,
(double) options.scale_data.min_value,
(double) options.scale_data.max_value,
(double) options.scale_data.step,
(double) page,
0.0);
if (options.common_data.vertical)
{
#if GTK_CHECK_VERSION(3,0,0)
scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adj));
#else
scale = gtk_vscale_new (GTK_ADJUSTMENT (adj));
#endif
gtk_range_set_inverted (GTK_RANGE (scale), !options.scale_data.invert);
}
else
{
#if GTK_CHECK_VERSION(3,0,0)
scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adj));
#else
scale = gtk_hscale_new (GTK_ADJUSTMENT (adj));
#endif
gtk_range_set_inverted (GTK_RANGE (scale), options.scale_data.invert);
}
gtk_widget_set_name (scale, "yad-scale-widget");
gtk_scale_set_digits (GTK_SCALE (scale), 0);
if (options.scale_data.hide_value)
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
/* add marks */
if (options.scale_data.marks)
{
GtkPositionType pos;
GSList *m = options.scale_data.marks;
pos = options.common_data.vertical ? GTK_POS_LEFT : GTK_POS_BOTTOM;
for (; m; m = m->next)
{
YadScaleMark *mark = (YadScaleMark *) m->data;
gtk_scale_add_mark (GTK_SCALE (scale), mark->value, pos, mark->name);
}
}
/* create container */
if (options.common_data.vertical)
{
#if GTK_CHECK_VERSION(3,0,0)
w = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
#else
w = gtk_vbox_new (FALSE, 1);
#endif
}
else
{
#if GTK_CHECK_VERSION(3,0,0)
w = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1);
#else
w = gtk_hbox_new (FALSE, 1);
#endif
}
/* create buttons */
if (options.scale_data.buttons)
{
minus_btn = gtk_button_new_with_label ("-");
gtk_button_set_relief (GTK_BUTTON (minus_btn), GTK_RELIEF_NONE);
g_signal_connect (G_OBJECT (minus_btn), "clicked", G_CALLBACK (vb_pressed), GINT_TO_POINTER (MINUS_BTN));
gtk_widget_set_sensitive (minus_btn, (options.scale_data.value > options.scale_data.min_value));
plus_btn = gtk_button_new_with_label ("+");
gtk_button_set_relief (GTK_BUTTON (plus_btn), GTK_RELIEF_NONE);
g_signal_connect (G_OBJECT (plus_btn), "clicked", G_CALLBACK (vb_pressed), GINT_TO_POINTER (PLUS_BTN));
gtk_widget_set_sensitive (plus_btn, (options.scale_data.value < options.scale_data.max_value));
}
/* create complex widget */
if (options.scale_data.buttons)
gtk_box_pack_start (GTK_BOX (w), options.common_data.vertical ? plus_btn : minus_btn, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (w), scale, TRUE, TRUE, 2);
if (options.scale_data.buttons)
gtk_box_pack_start (GTK_BOX (w), options.common_data.vertical ? minus_btn : plus_btn, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (scale), "value-changed", G_CALLBACK (value_changed_cb), NULL);
gtk_widget_grab_focus (scale);
return w;
}