static void
gtk_scale_button_set_orientation_private (GtkScaleButton *button,
GtkOrientation orientation)
{
GtkScaleButtonPrivate *priv = button->priv;
if (orientation != priv->orientation)
{
priv->orientation = orientation;
gtk_orientable_set_orientation (GTK_ORIENTABLE (priv->box),
orientation);
gtk_container_child_set (GTK_CONTAINER (priv->box),
button->plus_button,
"pack-type",
orientation == GTK_ORIENTATION_VERTICAL ?
GTK_PACK_START : GTK_PACK_END,
NULL);
gtk_container_child_set (GTK_CONTAINER (priv->box),
button->minus_button,
"pack-type",
orientation == GTK_ORIENTATION_VERTICAL ?
GTK_PACK_END : GTK_PACK_START,
NULL);
gtk_orientable_set_orientation (GTK_ORIENTABLE (priv->scale),
orientation);
if (orientation == GTK_ORIENTATION_VERTICAL)
{
gtk_widget_set_size_request (GTK_WIDGET (priv->scale),
-1, SCALE_SIZE);
gtk_range_set_inverted (GTK_RANGE (priv->scale), TRUE);
}
else
{
gtk_widget_set_size_request (GTK_WIDGET (priv->scale),
SCALE_SIZE, -1);
gtk_range_set_inverted (GTK_RANGE (priv->scale), FALSE);
}
/* FIXME: without this, the popup window appears as a square
* after changing the orientation
*/
gtk_window_resize (GTK_WINDOW (priv->dock), 1, 1);
g_object_notify (G_OBJECT (button), "orientation");
}
}
static GtkWidget *gl_create_water_plane (gl_preview_struct *gl_preview) {
GtkWidget *vbox, *scale;
// 1. Create Vbox for water control
vbox = gtk_vbox_new(FALSE,0);
gtk_widget_show(GTK_WIDGET(vbox));
if ((!gl_preview->use_water) || (!gl_preview->water_level))
// Nothing to do if pointers are NULL
return vbox;
// 2. Pack water label + check button on/off + scale in Vbox
define_label_in_box("Water", vbox, FALSE, TRUE, 0);
gl_preview->if_water_chkbox = gtk_check_button_new ();
gtk_widget_show (gl_preview->if_water_chkbox);
gtk_box_pack_start (GTK_BOX(vbox), align_widget(gl_preview->if_water_chkbox,ALIGN_CENTER, ALIGN_CENTER), FALSE, FALSE, DEF_PAD*0.5);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gl_preview->if_water_chkbox), *gl_preview->use_water);
gl_preview->adj_water_level = gtk_adjustment_new (*gl_preview->water_level, 0.0, 1.1, 0.01, 0.1, 0.1);
g_signal_connect (G_OBJECT(gl_preview->adj_water_level), "value_changed",
GTK_SIGNAL_FUNC(gfloat_adj_callb), gl_preview->water_level);
g_signal_connect (G_OBJECT(gl_preview->adj_water_level), "value_changed",
GTK_SIGNAL_FUNC(gl_area_redraw), gl_preview);
scale = define_scale_in_box (gl_preview->adj_water_level, vbox, 2, DEF_PAD*0.5);
gtk_range_set_inverted (GTK_RANGE(scale), TRUE);
g_signal_connect (G_OBJECT(gl_preview->if_water_chkbox), "toggled", GTK_SIGNAL_FUNC(sensitive_if_true), scale);
g_signal_connect (G_OBJECT(gl_preview->if_water_chkbox), "toggled",
GTK_SIGNAL_FUNC(toggle_check_button_callb), gl_preview->use_water);
g_signal_connect (G_OBJECT(gl_preview->if_water_chkbox), "toggled", GTK_SIGNAL_FUNC(gl_area_redraw), gl_preview);
return vbox;
}
static GtkWidget *am_create_mixer_ui (GtkWidget *switch_btn, char *name, GtkAdjustment *adj, GtkWidget *adv_btn) {
GtkWidget *vbox = NULL, *label = NULL, *img = NULL, *scale = NULL, *vhbox = NULL;
GtkWidget *spin = NULL;
vbox = gtk_vbox_new(FALSE, 2);
vhbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vhbox), switch_btn, TRUE, TRUE, 30);
gtk_box_pack_start(GTK_BOX(vbox), vhbox, FALSE, TRUE, 0);
label = gtk_label_new(name);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 8);
scale = gtk_vscale_new(adj);
gtk_widget_set_size_request(scale, -1, 200);
gtk_range_set_inverted(GTK_RANGE(scale), TRUE);
gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE);
g_object_set(G_OBJECT(scale), "can-focus", FALSE, NULL);
g_signal_connect(scale, "value-changed", G_CALLBACK(on_my_capture_mixer_changed), NULL);
gtk_box_pack_start(GTK_BOX(vbox), scale, FALSE, TRUE, 0);
vhbox = gtk_hbox_new(FALSE, 0);
spin = gtk_spin_button_new(adj, 1, 0);
gtk_box_pack_start(GTK_BOX(vhbox), spin, TRUE, TRUE, 24);
gtk_box_pack_start(GTK_BOX(vbox), vhbox, FALSE, TRUE, 2);
if(adv_btn)
gtk_box_pack_start(GTK_BOX(vbox), adv_btn, FALSE, TRUE, 2);
return vbox;
}
static void add_channel(struct channel *c)
{
c->vbox = gtk_vbox_new(FALSE, 5);
c->vscale = gtk_vscale_new(GTK_ADJUSTMENT(gtk_adjustment_new(
mixer_get(c), 0, 100, 0, 0, 0)));
gtk_scale_set_draw_value(GTK_SCALE(c->vscale), FALSE);
gtk_range_set_inverted(GTK_RANGE(c->vscale), TRUE);
gtk_container_add(GTK_CONTAINER(hbox), c->vbox);
gtk_box_pack_start(GTK_BOX(c->vbox), c->vscale, TRUE, TRUE, 0);
g_signal_connect((gpointer)c->vscale,
"value_changed", G_CALLBACK(vol_change), c);
g_signal_connect(c->vscale,
"scroll-event", G_CALLBACK(scale_scroll), c);
if (_has_switch(c->elem, c->playback)) {
c->mute = gtk_check_button_new_with_label(
c->playback ? _("Mute") : _("Capture"));
g_signal_connect((gpointer)c->mute,
"toggled", G_CALLBACK(mute), c);
gtk_box_pack_end(GTK_BOX(c->vbox), c->mute, FALSE, FALSE, 0);
}
update_gui(c);
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkRange_gtk_1range_1set_1inverted
(
JNIEnv* env,
jclass cls,
jlong _self,
jboolean _setting
)
{
GtkRange* self;
gboolean setting;
// convert parameter self
self = (GtkRange*) _self;
// convert parameter setting
setting = (gboolean) _setting;
// call function
gtk_range_set_inverted(self, setting);
// cleanup parameter self
// cleanup parameter setting
}
static void
invert (GtkButton *button)
{
GSList *l;
for (l = scales; l; l = l->next)
{
GtkRange *range = l->data;
gtk_range_set_inverted (range, !gtk_range_get_inverted (range));
}
}
VolBox *lamixer_volbox_new(const gchar *str, const gint mono, const gint mute, const glong minrange, const glong maxrange, snd_mixer_elem_t *elem, guint voltype)
{
VolBox *volumebox;
volumebox = g_malloc(sizeof(VolBox));
volumebox->minrange = minrange;
volumebox->maxrange = maxrange;
volumebox->type = voltype;
volumebox->volelem = elem;
volumebox->volbox = gtk_vbox_new(FALSE,0);
volumebox->volbarbox = gtk_hbox_new(FALSE,0);
volumebox->vollabel = gtk_label_new(str);
volumebox->volbar = gtk_vscale_new_with_range(minrange,maxrange,1.0);
gtk_range_set_inverted(GTK_RANGE(volumebox->volbar), TRUE);
gtk_scale_set_digits(GTK_SCALE(volumebox->volbar),0);
gtk_scale_set_value_pos(GTK_SCALE(volumebox->volbar),GTK_POS_BOTTOM);
//FIXME: Need any other method to set size
gtk_widget_set_size_request(GTK_WIDGET(volumebox->volbar),0,200);
if (!mono) {
volumebox->rvolbar = gtk_vscale_new_with_range(minrange,maxrange,1.0);
gtk_scale_set_digits(GTK_SCALE(volumebox->rvolbar),0);
gtk_range_set_inverted(GTK_RANGE(volumebox->rvolbar), TRUE);
gtk_scale_set_value_pos(GTK_SCALE(volumebox->rvolbar),GTK_POS_BOTTOM);
gtk_widget_set_size_request(GTK_WIDGET(volumebox->rvolbar),0,200);
volumebox->lockswitch = gtk_check_button_new_with_label("Lock");
}
else {
volumebox->rvolbar = NULL;
volumebox->lockswitch = NULL;
}
if (mute)
volumebox->muteswitch = gtk_check_button_new_with_label("Mute");
else
volumebox->muteswitch = NULL;
return volumebox;
}
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_acceptsFocus = true;
m_needParent = true;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxSlider creation failed") );
return false;
}
m_pos = 0;
m_scrollEventType = 0;
m_needThumbRelease = false;
if (style & wxSL_VERTICAL)
m_widget = gtk_vscale_new( (GtkAdjustment *) NULL );
else
m_widget = gtk_hscale_new( (GtkAdjustment *) NULL );
gtk_scale_set_draw_value(GTK_SCALE (m_widget), (style & wxSL_LABELS) != 0);
// Keep full precision in position value
gtk_scale_set_digits(GTK_SCALE (m_widget), -1);
if (style & wxSL_INVERSE)
gtk_range_set_inverted( GTK_RANGE(m_widget), TRUE );
g_signal_connect(m_widget, "button_press_event", G_CALLBACK(gtk_button_press_event), this);
g_signal_connect(m_widget, "button_release_event", G_CALLBACK(gtk_button_release_event), this);
g_signal_connect(m_widget, "move_slider", G_CALLBACK(gtk_move_slider), this);
g_signal_connect(m_widget, "format_value", G_CALLBACK(gtk_format_value), NULL);
g_signal_connect(m_widget, "value_changed", G_CALLBACK(gtk_value_changed), this);
gulong handler_id;
handler_id = g_signal_connect(
m_widget, "event_after", G_CALLBACK(gtk_event_after), this);
g_signal_handler_block(m_widget, handler_id);
SetRange( minValue, maxValue );
SetValue( value );
m_parent->DoAddChild( this );
PostCreation(size);
return true;
}
static GtkWidget *
gtk_scale_button_scale_box_new (GtkScaleButton *button)
{
GtkScaleButtonPrivate *priv = button->priv;
GtkScaleButtonVScale *scale;
GtkWidget *box;
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
{
box = gtk_vbox_new (FALSE, 0);
scale = g_object_new (GTK_TYPE_SCALE_BUTTON_VSCALE, NULL);
priv->scale = GTK_WIDGET (scale);
gtk_widget_set_size_request (priv->scale, -1, SCALE_SIZE);
gtk_range_set_inverted (GTK_RANGE (priv->scale), TRUE);
gtk_box_pack_start (GTK_BOX (box), button->plus_button, TRUE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), priv->scale, TRUE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), button->minus_button, TRUE, FALSE, 0);
}
else
{
box = gtk_hbox_new (FALSE, 0);
scale = g_object_new (GTK_TYPE_SCALE_BUTTON_HSCALE, NULL);
priv->scale = GTK_WIDGET (scale);
gtk_widget_set_size_request (priv->scale, SCALE_SIZE, -1);
gtk_box_pack_start (GTK_BOX (box), button->minus_button, TRUE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), priv->scale, TRUE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), button->plus_button, TRUE, FALSE, 0);
}
gtk_scale_set_draw_value (GTK_SCALE (priv->scale), FALSE);
gtk_range_set_adjustment (GTK_RANGE (scale),
GTK_ADJUSTMENT (priv->adjustment));
scale->button = button;
g_signal_connect (priv->scale, "grab-notify",
G_CALLBACK (cb_scale_grab_notify), button);
/* FIXME: without this, the popup window appears as a square
* after changing the orientation
*/
gtk_window_resize (GTK_WINDOW (priv->dock), 1, 1);
return box;
}
GtkWidget *mixer_build_widget (gboolean bHorizontal)
{
g_return_val_if_fail (myData.pControledElement != NULL, NULL);
GtkWidget *pScale = gtk_scale_new_with_range (bHorizontal ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL, 0., 100., .5*myConfig.iScrollVariation);
if (! bHorizontal)
gtk_range_set_inverted (GTK_RANGE (pScale), TRUE); // de bas en haut.
myData.iCurrentVolume = cd_get_volume ();
gtk_range_set_value (GTK_RANGE (pScale), myData.iCurrentVolume);
g_signal_connect (G_OBJECT (pScale),
"value-changed",
G_CALLBACK (on_change_volume),
NULL);
gldi_dialog_set_widget_text_color (pScale);
return pScale;
}
int main (int argc, char ** argv)
{
GtkWidget *window;
GtkWidget *cpu;
GtkWidget *fixed;
GtkWidget *scale;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "CPU widget");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window), 200, 180);
//gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
fixed = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed);
cpu = gtk_cpu_new();
gtk_fixed_put(GTK_FIXED(fixed), cpu, 30, 40);
scale = gtk_vscale_new_with_range(0.0, 100.0, 1.0);
gtk_range_set_inverted(GTK_RANGE(scale), TRUE);
gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_TOP);
gtk_widget_set_size_request(scale, 50, 120);
gtk_fixed_put(GTK_FIXED(fixed), scale, 130, 20);
g_signal_connect(G_OBJECT(scale), "value_changed", G_CALLBACK(set_value), (gpointer) cpu);
gtk_widget_show(cpu);
gtk_widget_show(fixed);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static void create_volume_scale(void)
{
// Create a popup window
window = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(window), TRUE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(window), TRUE);
gtk_window_set_keep_above(GTK_WINDOW(window), TRUE);
gtk_window_set_default_size(GTK_WINDOW(window), 0, 120);
// Create the scale and add it to the window
scale = gtk_scale_new_with_range(GTK_ORIENTATION_VERTICAL, 0.0, 100.0, 1.0);
gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE);
gtk_range_set_inverted(GTK_RANGE(scale), TRUE);
gtk_container_add(GTK_CONTAINER(window), scale);
gtk_widget_show(scale);
// Connect the value changed signal
g_signal_connect(G_OBJECT(scale), "value-changed", G_CALLBACK(on_scale_value_change), NULL);
}
void
ags_drum_input_line_init(AgsDrumInputLine *drum_input_line)
{
AgsLineMember *line_member;
GtkWidget *widget;
g_signal_connect_after((GObject *) drum_input_line, "parent_set\0",
G_CALLBACK(ags_drum_input_line_parent_set_callback), (gpointer) drum_input_line);
line_member = (AgsLineMember *) g_object_new(AGS_TYPE_LINE_MEMBER,
"widget-type\0", GTK_TYPE_VSCALE,
"plugin-name\0", "ags-volume\0",
"specifier\0", "./volume[0]\0",
"control-port\0", "1/1\0",
NULL);
ags_expander_add(AGS_LINE(drum_input_line)->expander,
GTK_WIDGET(line_member),
0, 0,
1, 1);
widget = gtk_bin_get_child(GTK_BIN(line_member));
gtk_scale_set_digits(GTK_SCALE(widget),
3);
gtk_range_set_range(GTK_RANGE(widget),
0.0, 2.00);
gtk_range_set_increments(GTK_RANGE(widget),
0.025, 0.1);
gtk_range_set_value(GTK_RANGE(widget),
1.0);
gtk_range_set_inverted(GTK_RANGE(widget),
TRUE);
gtk_widget_set_size_request(widget,
-1, 100);
g_object_set(G_OBJECT(line_member),
"port-data\0", (gpointer) &(GTK_RANGE(widget)->adjustment->value),
NULL);
}
static GtkWidget *
volume_create_slider(volume_priv *c)
{
GtkWidget *slider, *win;
GtkWidget *frame;
win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(win), 180, 180);
gtk_window_set_decorated(GTK_WINDOW(win), FALSE);
gtk_window_set_resizable(GTK_WINDOW(win), FALSE);
gtk_container_set_border_width(GTK_CONTAINER(win), 1);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(win), TRUE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(win), TRUE);
gtk_window_set_position(GTK_WINDOW(win), GTK_WIN_POS_MOUSE);
gtk_window_stick(GTK_WINDOW(win));
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(win), frame);
gtk_container_set_border_width(GTK_CONTAINER(frame), 1);
slider = gtk_vscale_new_with_range(0.0, 100.0, 1.0);
gtk_widget_set_size_request(slider, 25, 82);
gtk_scale_set_draw_value(GTK_SCALE(slider), TRUE);
gtk_scale_set_value_pos(GTK_SCALE(slider), GTK_POS_BOTTOM);
gtk_scale_set_digits(GTK_SCALE(slider), 0);
gtk_range_set_inverted(GTK_RANGE(slider), TRUE);
gtk_range_set_value(GTK_RANGE(slider), ((meter_priv *) c)->level);
DBG("meter->level %f\n", ((meter_priv *) c)->level);
g_signal_connect(G_OBJECT(slider), "value_changed",
G_CALLBACK(slider_changed), c);
g_signal_connect(G_OBJECT(slider), "enter-notify-event",
G_CALLBACK(crossed), (gpointer)c);
g_signal_connect(G_OBJECT(slider), "leave-notify-event",
G_CALLBACK(crossed), (gpointer)c);
gtk_container_add(GTK_CONTAINER(frame), slider);
c->slider = slider;
return win;
}
GtkWidget *
make_selection_view ( GjayApp *gjay ) {
GtkWidget * vbox1, * vbox2, * hbox1, * hbox2;
GtkWidget * alignment, * event_box, * swin, *color_button;
GtkCellRenderer * text_renderer, * pixbuf_renderer;
GtkTreeViewColumn *column;
struct play_songs_data *psd;
vbox1 = gtk_vbox_new (FALSE, 2);
hbox1 = gtk_hbox_new (FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, FALSE, 2);
icon = gtk_image_new_from_pixbuf (gjay_get_pixbuf(gjay->gui, PM_ICON_CLOSED));
gtk_box_pack_start(GTK_BOX(hbox1), icon, FALSE, FALSE, 2);
vbox2 = gtk_vbox_new(FALSE, 2);
label_name = gtk_label_new("");
label_type = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(hbox1), vbox2, FALSE, FALSE, 2);
alignment = gtk_alignment_new (0, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment), label_name);
gtk_box_pack_start(GTK_BOX(vbox2), alignment, FALSE, FALSE, 2);
alignment = gtk_alignment_new (0, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment), label_type);
gtk_box_pack_start(GTK_BOX(vbox2), alignment, FALSE, FALSE, 2);
alignment = gtk_alignment_new (1, 0.5, 0, 0);
gtk_box_pack_start(GTK_BOX(hbox1), alignment, TRUE, TRUE, 2);
hbox2 = gtk_hbox_new (FALSE, 2);
gtk_container_add(GTK_CONTAINER(alignment), hbox2);
event_box = gtk_event_box_new ();
gtk_box_pack_start(GTK_BOX(hbox2), event_box, FALSE, FALSE, 2);
play = gtk_image_new_from_pixbuf(gjay->gui->pixbufs[PM_BUTTON_PLAY]);
gtk_widget_set_tooltip_text(event_box,
"Play the selected songs in the music player");
gtk_container_add (GTK_CONTAINER(event_box), play);
gtk_widget_set_events (event_box, GDK_BUTTON_PRESS_MASK);
psd = g_malloc0(sizeof(struct play_songs_data));
psd->player = gjay->player;
psd->main_window = gjay->gui->main_window;
psd->playlist = gjay->selected_songs;
g_signal_connect (G_OBJECT(event_box), "button_press_event",
G_CALLBACK(play_selected), psd);
event_box = gtk_event_box_new ();
gtk_box_pack_start(GTK_BOX(hbox2), event_box, FALSE, FALSE, 2);
event_box = gtk_event_box_new ();
gtk_box_pack_start(GTK_BOX(hbox2), event_box, FALSE, FALSE, 2);
select_all_recursive = gtk_image_new_from_pixbuf(gjay->gui->pixbufs[PM_BUTTON_ALL]);
gtk_widget_set_tooltip_text (event_box,
"Select all songs in this directory");
gtk_container_add (GTK_CONTAINER(event_box), select_all_recursive);
gtk_widget_set_events (event_box, GDK_BUTTON_PRESS_MASK);
g_signal_connect(G_OBJECT(event_box), "button_press_event",
G_CALLBACK (select_all_selected), gjay);
vbox_lower = gtk_vbox_new (FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox1), vbox_lower, TRUE, TRUE, 2);
list_store = gtk_list_store_new(LAST_COLUMN,
G_TYPE_STRING,
G_TYPE_STRING,
GDK_TYPE_PIXBUF,
G_TYPE_STRING);
tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
g_object_unref (G_OBJECT (list_store));
text_renderer = gtk_cell_renderer_text_new ();
pixbuf_renderer = gtk_cell_renderer_pixbuf_new ();
column = gtk_tree_view_column_new_with_attributes ("Artist", text_renderer,
"text", ARTIST_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
column = gtk_tree_view_column_new_with_attributes ("Title", text_renderer,
"text", TITLE_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
column = gtk_tree_view_column_new_with_attributes ("Freq", pixbuf_renderer,
"pixbuf", FREQ_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
column = gtk_tree_view_column_new_with_attributes ("BPM", text_renderer,
"text", BPM_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
swin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(swin), tree);
gtk_box_pack_start(GTK_BOX(vbox_lower), swin, TRUE, TRUE, 2);
hbox2 = gtk_hbox_new (FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_lower), hbox2, FALSE, FALSE, 2);
color_button = colorbutton_new(gjay);
colorbutton_set_callback(GTK_COLOR_BUTTON(color_button),
G_CALLBACK(update_selected_songs_color),
gjay);
gtk_box_pack_start(GTK_BOX(hbox2), color_button, FALSE, FALSE, 2);
alignment = gtk_alignment_new (0, 1, 0.1, 0.1);
gtk_box_pack_start(GTK_BOX(hbox2), alignment, FALSE, FALSE, 2);
rating_vbox = gtk_vbox_new (FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbox2), rating_vbox, TRUE, FALSE, 2);
label_rating = gtk_label_new("Rating");
gtk_box_pack_start(GTK_BOX(rating_vbox), label_rating, FALSE, FALSE, 2);
rating = gtk_vscale_new_with_range (MIN_RATING,
MAX_RATING,
0.2);
g_signal_connect (G_OBJECT(rating), "value-changed",
G_CALLBACK (rating_changed), gjay);
gtk_range_set_inverted(GTK_RANGE(rating), TRUE);
alignment = gtk_alignment_new (0.5, 0,
0.5, 1);
gtk_container_add(GTK_CONTAINER(alignment), rating);
gtk_box_pack_start(GTK_BOX(rating_vbox), alignment, TRUE, TRUE, 2);
return vbox1;
}
static void fill_sample_table(DrMrUi* ui, int samples, char** names,GtkWidget** gain_sliders, GtkWidget** pan_sliders) {
int row = 0;
int col = 0;
int si;
gchar buf[64];
int rows = (samples/ui->cols);
if (samples % ui->cols != 0) rows++;
gtk_table_resize(ui->sample_table,rows,ui->cols);
switch (ui->startSamp) {
case 1: // bottom left
row = rows-1;
break;
case 2: // top right
col = ui->cols-1;
break;
case 3: // bottom right
row = rows-1;
col = ui->cols-1;
break;
}
for(si = 0;si<samples;si++) {
GtkWidget *frame,*hbox,*gain_vbox,*pan_vbox;
GtkWidget* gain_slider;
GtkWidget* pan_slider;
GtkWidget* gain_label;
GtkWidget* pan_label;
gboolean slide_expand;
snprintf(buf,64,"<b>%s</b> (%i)",names[si],si);
frame = gtk_frame_new(buf);
gtk_label_set_use_markup(GTK_LABEL(gtk_frame_get_label_widget(GTK_FRAME(frame))),true);
gtk_frame_set_shadow_type(GTK_FRAME(frame),GTK_SHADOW_OUT);
hbox = gtk_hbox_new(false,0);
#ifdef NO_NKNOB
gain_slider = gtk_vscale_new_with_range(GAIN_MIN,6.0,1.0);
gtk_scale_set_value_pos(GTK_SCALE(gain_slider),GTK_POS_BOTTOM);
gtk_scale_set_digits(GTK_SCALE(gain_slider),1);
gtk_scale_add_mark(GTK_SCALE(gain_slider),0.0,GTK_POS_RIGHT,"0 dB");
// Hrmm, -inf label is at top in ardour for some reason
//gtk_scale_add_mark(GTK_SCALE(gain_slider),GAIN_MIN,GTK_POS_RIGHT,"-inf");
gtk_range_set_inverted(GTK_RANGE(gain_slider),true);
slide_expand = true;
#else
gain_slider = n_knob_new_with_range(0.0,GAIN_MIN,6.0,1.0);
n_knob_set_load_prefix(N_KNOB(gain_slider),ui->bundle_path);
gtk_widget_set_has_tooltip(gain_slider,TRUE);
slide_expand = false;
#endif
g_object_set_qdata (G_OBJECT(gain_slider),ui->gain_quark,GINT_TO_POINTER(si));
if (gain_sliders) gain_sliders[si] = gain_slider;
if (si < 32)
gtk_range_set_value(GTK_RANGE(gain_slider),ui->gain_vals[si]);
else // things are gross if we have > 32 samples, what to do?
gtk_range_set_value(GTK_RANGE(gain_slider),0.0);
g_signal_connect(G_OBJECT(gain_slider),"change-value",G_CALLBACK(gain_callback),ui);
gain_label = gtk_label_new("Gain");
gain_vbox = gtk_vbox_new(false,0);
#ifdef NO_NKNOB
pan_slider = gtk_hscale_new_with_range(-1.0,1.0,0.1);
gtk_scale_add_mark(GTK_SCALE(pan_slider),0.0,GTK_POS_TOP,NULL);
#else
pan_slider = n_knob_new_with_range(0.0,-1.0,1.0,0.1);
n_knob_set_load_prefix(N_KNOB(pan_slider),ui->bundle_path);
gtk_widget_set_has_tooltip(pan_slider,TRUE);
#endif
if (pan_sliders) pan_sliders[si] = pan_slider;
if (si < 32)
gtk_range_set_value(GTK_RANGE(pan_slider),ui->pan_vals[si]);
else
gtk_range_set_value(GTK_RANGE(pan_slider),0);
g_object_set_qdata (G_OBJECT(pan_slider),ui->pan_quark,GINT_TO_POINTER(si));
g_signal_connect(G_OBJECT(pan_slider),"change-value",G_CALLBACK(pan_callback),ui);
pan_label = gtk_label_new("Pan");
pan_vbox = gtk_vbox_new(false,0);
gtk_box_pack_start(GTK_BOX(gain_vbox),gain_slider,slide_expand,slide_expand,0);
gtk_box_pack_start(GTK_BOX(gain_vbox),gain_label,false,false,0);
gtk_box_pack_start(GTK_BOX(pan_vbox),pan_slider,slide_expand,slide_expand,0);
gtk_box_pack_start(GTK_BOX(pan_vbox),pan_label,false,false,0);
gtk_box_pack_start(GTK_BOX(hbox),gain_vbox,true,true,0);
gtk_box_pack_start(GTK_BOX(hbox),pan_vbox,true,true,0);
gtk_container_add(GTK_CONTAINER(frame),hbox);
gtk_table_attach_defaults(ui->sample_table,frame,col,col+1,row,row+1);
if (ui->startSamp > 1) {
col--;
if (col < 0) {
if (ui->startSamp == 2)
row++;
else
row--;
col = ui->cols-1;
}
}
else {
col++;
if (col >= ui->cols) {
if (ui->startSamp == 0)
row++;
else
row--;
col = 0;
}
}
}
gtk_widget_queue_resize(GTK_WIDGET(ui->sample_table));
}
int main(int argc, char *argv[]){
/* global variables to be reused */
unsigned int uint = 0;
/* Declare all widgets here */
GtkWidget * window;
GtkWidget * notebook;
GtkWidget * spacer; /* this is a spacer for grid */
GtkWidget * page_volume_label;
GtkWidget * page_volume_grid;
GtkWidget * page_volume_scale;
GtkWidget * page_volume_scale_label;
GtkWidget * page_volume_mute_toggle;
GtkWidget * page_browser_label;
GtkWidget * page_browser_grid;
GtkWidget * page_browser_button;
//GtkWidget * page_browser_pid_label;
gtk_init(&argc, &argv);
/* Create a new window. This is the parent window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (window), "Control Panel");
gtk_window_set_default_size(GTK_WINDOW (window), 200, 300);
/* Create spacer */
spacer = gtk_label_new(" ");
/* Create a new notebook */
notebook = gtk_notebook_new();
gtk_container_add(GTK_CONTAINER (window), notebook);
/* Page VOLUME config */
/* label */
page_volume_label = gtk_label_new("Volume Settings");
/* volume scale */
page_volume_scale = gtk_scale_new_with_range(GTK_ORIENTATION_VERTICAL,0,100,1);
gtk_range_set_inverted(GTK_RANGE (page_volume_scale), TRUE);
gtk_scale_add_mark(GTK_SCALE (page_volume_scale), 0, GTK_POS_RIGHT, "0");
gtk_scale_add_mark(GTK_SCALE (page_volume_scale), 25, GTK_POS_RIGHT, "25");
gtk_scale_add_mark(GTK_SCALE (page_volume_scale), 50, GTK_POS_RIGHT, "50");
gtk_scale_add_mark(GTK_SCALE (page_volume_scale), 75, GTK_POS_RIGHT, "75");
gtk_scale_add_mark(GTK_SCALE (page_volume_scale), 100, GTK_POS_RIGHT, "100");
gtk_scale_set_draw_value(GTK_SCALE (page_volume_scale), 1);
initializeVolumeScale(page_volume_scale);
/* scale label, Master */
page_volume_scale_label = gtk_label_new("Master");
/* checkbox for mute option */
page_volume_mute_toggle = gtk_toggle_button_new_with_label("Mute / Unmute");
/* page grid for layout */
page_volume_grid = gtk_grid_new();
gtk_grid_attach(GTK_GRID (page_volume_grid), spacer, 0, 0, 5, 20);
gtk_grid_attach(GTK_GRID (page_volume_grid), page_volume_scale_label, 4, 5, 10, 5);
gtk_grid_attach(GTK_GRID (page_volume_grid), page_volume_scale, 5, 20, 10, 30);
gtk_widget_set_hexpand(page_volume_scale, TRUE);
gtk_widget_set_vexpand(page_volume_scale, TRUE);
gtk_grid_attach(GTK_GRID (page_volume_grid), page_volume_mute_toggle, 7, 50, 4, 4);
/* page */
gtk_notebook_insert_page(GTK_NOTEBOOK (notebook),page_volume_grid,page_volume_label, 0);
/* signal listener */
g_signal_connect(page_volume_scale, "value-changed", G_CALLBACK (adjustVolume), page_volume_scale);
g_signal_connect(page_volume_mute_toggle, "toggled", G_CALLBACK (muteVolume), page_volume_mute_toggle);
/* Page BROWSER config */
/* page label */
page_browser_label = gtk_label_new("Web Browser");
/* page button to open browser */
page_browser_button = gtk_button_new_with_label("Start Firefox");
/* page pid label that shows pid of browsers */
//page_browser_pid_label = gtk_label_new("Test");
/*page grid */
page_browser_grid = gtk_grid_new();
spacer = gtk_label_new(" ");
gtk_grid_attach(GTK_GRID (page_browser_grid), spacer, 0, 0, 10, 10);
gtk_grid_attach(GTK_GRID (page_browser_grid), page_browser_button, 10, 10, 15, 5);
spacer = gtk_label_new(" ");
gtk_grid_attach(GTK_GRID (page_browser_grid), spacer, 10, 5, 10, 10);
//gtk_grid_attach(GTK_GRID (page_browser_grid), page_browser_pid_label, 20, 50, 10, 5);
/*page */
gtk_notebook_insert_page(GTK_NOTEBOOK (notebook), page_browser_grid, page_browser_label, 1);
/* listeners */
g_signal_connect(page_browser_button, "released", G_CALLBACK (openFirefox), spacer);//page_browser_pid_label);
/* Finally ... */
gtk_widget_show_all(window);
gtk_main ();
return 0;
}
GtkWidget *
scale_create_widget (GtkWidget *dlg)
{
GtkWidget *w;
GtkObject *adj;
gint page;
if (options.scale_data.min_value >= options.scale_data.max_value)
{
g_printerr (_("Maximum value must be greater than minimum value.\n"));
return NULL;
}
/* check for initial value */
if (options.scale_data.have_value)
{
if (options.scale_data.value < options.scale_data.min_value)
{
g_printerr (_("Initial value less than minimal.\n"));
options.scale_data.value = options.scale_data.min_value;
}
else if (options.scale_data.value > options.scale_data.max_value)
{
g_printerr (_("Initial value greater than maximum.\n"));
options.scale_data.value = options.scale_data.max_value;
}
}
else
options.scale_data.value = options.scale_data.min_value;
page = options.scale_data.page == -1 ? options.scale_data.step * 10 : options.scale_data.page;
adj = gtk_adjustment_new ((double) options.scale_data.value,
(double) options.scale_data.min_value,
(double) options.scale_data.max_value,
(double) options.scale_data.step,
(double) page, 0.0);
if (options.scale_data.vertical)
{
w = scale = gtk_vscale_new (GTK_ADJUSTMENT (adj));
gtk_widget_set_name (w, "yad-vscale-widget");
gtk_range_set_inverted (GTK_RANGE (w), !options.scale_data.invert);
}
else
{
w = scale = gtk_hscale_new (GTK_ADJUSTMENT (adj));
gtk_widget_set_name (w, "yad-hscale-widget");
gtk_range_set_inverted (GTK_RANGE (w), options.scale_data.invert);
}
gtk_scale_set_digits (GTK_SCALE (w), 0);
if (options.scale_data.print_partial)
g_signal_connect (G_OBJECT (w), "value-changed",
G_CALLBACK (value_changed_cb), NULL);
if (options.scale_data.hide_value)
gtk_scale_set_draw_value (GTK_SCALE (w), FALSE);
/* add marks */
if (options.scale_data.marks)
{
GtkPositionType pos;
GSList *m = options.scale_data.marks;
pos = options.scale_data.vertical ? GTK_POS_LEFT : GTK_POS_BOTTOM;
for (; m; m = m->next)
{
YadScaleMark *mark = (YadScaleMark *) m->data;
gtk_scale_add_mark (GTK_SCALE (w), mark->value, pos, mark->name);
}
}
return w;
}
GtkWidget*
create_volume_window (void)
{
accel_group = gtk_accel_group_new ();
volume_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (volume_window, 60, 240);
gtk_container_set_border_width (GTK_CONTAINER (volume_window), 2);
gtk_window_set_resizable (GTK_WINDOW (volume_window), FALSE);
gtk_window_set_position (GTK_WINDOW (volume_window), GTK_WIN_POS_MOUSE);
gtk_window_set_decorated (GTK_WINDOW (volume_window), FALSE);
gtk_window_set_skip_taskbar_hint( GTK_WINDOW (volume_window), TRUE );
frame = gtk_frame_new (_("Volume"));
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (frame), vbox1);
gtk_container_add (GTK_CONTAINER (volume_window), frame);
gtk_widget_show (frame);
vol_adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 100, 1, 10, 0));
/* get original adjustments */
get_current_levels();
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, TRUE, 8);
/* ajustment, climb rate, digits */
spinbutton1 = gtk_spin_button_new (GTK_ADJUSTMENT (vol_adjustment), 1, 0);
gtk_widget_show (spinbutton1);
gtk_box_pack_start (GTK_BOX (hbox1), spinbutton1, TRUE, FALSE, 0);
gtk_widget_set_size_request (spinbutton1, -1, 22);
g_signal_connect ((gpointer) spinbutton1, "value-changed",
G_CALLBACK (on_spinbutton1_button_release_event),
NULL);
g_object_set_data_full(G_OBJECT (volume_window), "spinbutton1",
gtk_widget_ref (spinbutton1),
(GDestroyNotify) gtk_widget_unref);
hbox3 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox3);
gtk_box_pack_start (GTK_BOX (vbox1), hbox3, TRUE, TRUE, 5);
vscale1 = gtk_vscale_new (GTK_ADJUSTMENT (vol_adjustment));
gtk_widget_show (vscale1);
gtk_range_set_inverted (GTK_RANGE (vscale1), TRUE);
gtk_box_pack_start (GTK_BOX (hbox3), vscale1, TRUE, TRUE, 0);
gtk_scale_set_draw_value (GTK_SCALE (vscale1), FALSE);
g_signal_connect ((gpointer) vscale1, "button-release-event",
G_CALLBACK (on_vscale1_button_release_event),
vol_adjustment);
g_object_set_data_full(G_OBJECT (volume_window), "vscale1",
gtk_widget_ref (vscale1),
(GDestroyNotify) gtk_widget_unref);
hbox4 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox4);
gtk_box_pack_start (GTK_BOX (vbox1), hbox4, FALSE, TRUE, 8);
g_signal_connect ((gpointer) volume_window, "destroy",
G_CALLBACK (gtk_widget_destroy),
NULL);
g_object_set_data (G_OBJECT (volume_window), "volume_window", volume_window);
g_object_set_data_full (G_OBJECT (volume_window), "frame",
gtk_widget_ref (frame),
(GDestroyNotify) gtk_widget_unref);
g_object_set_data_full (G_OBJECT (volume_window), "vbox1",
gtk_widget_ref (vbox1),
(GDestroyNotify) gtk_widget_unref);
g_object_set_data_full (G_OBJECT (volume_window), "hbox1",
gtk_widget_ref (hbox1),
(GDestroyNotify) gtk_widget_unref);
g_object_set_data_full (G_OBJECT (volume_window), "hbox3",
gtk_widget_ref (hbox3),
(GDestroyNotify) gtk_widget_unref);
g_object_set_data_full (G_OBJECT (volume_window), "hbox4",
gtk_widget_ref (hbox4),
(GDestroyNotify) gtk_widget_unref);
gtk_window_add_accel_group (GTK_WINDOW (volume_window), accel_group);
vol_spin = spinbutton1;
return volume_window;
}
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;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxSlider creation failed") );
return false;
}
if (style & wxSL_VERTICAL)
m_scale = gtk_vscale_new( NULL );
else
m_scale = gtk_hscale_new( NULL );
g_object_ref(m_scale);
if (style & wxSL_MIN_MAX_LABELS)
{
gtk_widget_show( m_scale );
if (style & wxSL_VERTICAL)
m_widget = gtk_hbox_new(false, 0);
else
m_widget = gtk_vbox_new(false, 0);
g_object_ref(m_widget);
gtk_container_add( GTK_CONTAINER(m_widget), m_scale );
GtkWidget *box;
if (style & wxSL_VERTICAL)
box = gtk_vbox_new(false,0);
else
box = gtk_hbox_new(false,0);
g_object_ref(box);
gtk_widget_show(box);
gtk_container_add( GTK_CONTAINER(m_widget), box );
m_minLabel = gtk_label_new(NULL);
g_object_ref(m_minLabel);
gtk_widget_show( m_minLabel );
gtk_container_add( GTK_CONTAINER(box), m_minLabel );
gtk_box_set_child_packing( GTK_BOX(box), m_minLabel, FALSE, FALSE, 0, GTK_PACK_START );
// expanding empty space between the min/max labels
GtkWidget *space = gtk_label_new(NULL);
g_object_ref(space);
gtk_widget_show( space );
gtk_container_add( GTK_CONTAINER(box), space );
gtk_box_set_child_packing( GTK_BOX(box), space, TRUE, FALSE, 0, GTK_PACK_START );
m_maxLabel = gtk_label_new(NULL);
g_object_ref(m_maxLabel);
gtk_widget_show( m_maxLabel );
gtk_container_add( GTK_CONTAINER(box), m_maxLabel );
gtk_box_set_child_packing( GTK_BOX(box), m_maxLabel, FALSE, FALSE, 0, GTK_PACK_END );
}
else
{
m_widget = m_scale;
m_maxLabel = NULL;
m_minLabel = NULL;
}
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;
}
static void
widget_overlay_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
WidgetOverlay *ovl = WIDGET_OVERLAY (object);
if (ovl->priv) {
switch (param_id) {
case PROP_ADD_SCALE: {
gboolean need_scale;
need_scale = g_value_get_boolean (value);
if (!need_scale && !ovl->priv->scale_child)
return;
if (need_scale && ovl->priv->scale_child) {
widget_overlay_set_child_props (ovl, ovl->priv->scale_child->child,
WIDGET_OVERLAY_CHILD_ALPHA, .6,
-1);
}
else if (need_scale) {
GtkWidget *box, *wid, *button, *image;
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
wid = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
SCALE_MIN, SCALE_MAX, SCALE_STEP);
ovl->priv->scale_range = GTK_RANGE (wid);
g_object_set (G_OBJECT (wid), "draw-value", FALSE, NULL);
gtk_box_pack_start (GTK_BOX (box), wid, TRUE, TRUE, 0);
button = gtk_button_new ();
image = gtk_image_new_from_icon_name ("window-close-symbolic",
GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER (button), image);
gtk_container_add (GTK_CONTAINER (box), button);
gtk_widget_set_name (button, "browser-tab-close-button");
g_signal_connect (button, "clicked",
G_CALLBACK (scale_button_clicked_cb), ovl);
gtk_container_add (GTK_CONTAINER (ovl), box);
gtk_widget_show_all (box);
GList *list;
for (list = ovl->priv->children; list; list = list->next) {
ChildData *cd = (ChildData*) list->data;
if (cd->child == box) {
ovl->priv->scale_child = cd;
break;
}
}
g_assert (ovl->priv->scale_child);
ChildData *cd;
cd = get_first_child (ovl);
if (cd)
gtk_range_set_value (ovl->priv->scale_range, cd->scale);
gtk_range_set_inverted (ovl->priv->scale_range, TRUE);
g_signal_connect (wid, "value-changed",
G_CALLBACK (scale_value_changed_cb), ovl);
widget_overlay_set_child_props (ovl, box,
WIDGET_OVERLAY_CHILD_VALIGN,
WIDGET_OVERLAY_ALIGN_FILL,
WIDGET_OVERLAY_CHILD_HALIGN,
WIDGET_OVERLAY_ALIGN_END,
WIDGET_OVERLAY_CHILD_SCALE, 1.,
WIDGET_OVERLAY_CHILD_ALPHA, .6,
-1);
}
else {
widget_overlay_set_child_props (ovl, ovl->priv->scale_child->child,
WIDGET_OVERLAY_CHILD_ALPHA, 0.,
-1);
}
break;
}
}
}
}
int
gtkui_run_dialog (GtkWidget *parentwin, ddb_dialog_t *conf, uint32_t buttons, int (*callback)(int button, void *ctx), void *ctx) {
if (!parentwin) {
parentwin = mainwin;
}
// create window
char title[200];
snprintf (title, sizeof (title), _("Configure %s"), conf->title);
GtkWidget *win;
if (!buttons) {
win = gtk_dialog_new_with_buttons (title, GTK_WINDOW (parentwin), GTK_DIALOG_MODAL, GTK_STOCK_APPLY, GTK_RESPONSE_APPLY, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
gtk_dialog_set_default_response (GTK_DIALOG (win), GTK_RESPONSE_OK);
}
else {
win = gtk_dialog_new_with_buttons (title, GTK_WINDOW (parentwin), GTK_DIALOG_MODAL, NULL);
if (buttons & (1<<ddb_button_ok)) {
gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_OK, GTK_RESPONSE_OK);
}
if (buttons & (1<<ddb_button_cancel)) {
gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
}
if (buttons & (1<<ddb_button_close)) {
gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
}
if (buttons & (1<<ddb_button_apply)) {
gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_APPLY, GTK_RESPONSE_APPLY);
}
if (buttons & (1<<ddb_button_yes)) {
gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_YES, GTK_RESPONSE_YES);
}
if (buttons & (1<<ddb_button_no)) {
gtk_dialog_add_button (GTK_DIALOG (win), GTK_STOCK_NO, GTK_RESPONSE_NO);
}
}
gtk_window_set_type_hint (GTK_WINDOW (win), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_container_set_border_width (GTK_CONTAINER(win), 12);
gtk_window_set_title (GTK_WINDOW (win), title);
gtk_window_set_modal (GTK_WINDOW (win), TRUE);
gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (parentwin));
GtkWidget *widgets[100] = {NULL};
int pack[100] = {0};
int ncurr = 0;
widgets[ncurr] = gtk_dialog_get_content_area (GTK_DIALOG (win));
gtk_box_set_spacing (GTK_BOX (widgets[ncurr]), 8);
GtkWidget *action_area = gtk_dialog_get_action_area (GTK_DIALOG (win));
gtk_widget_show (action_area);
gtk_button_box_set_layout (GTK_BUTTON_BOX (action_area), GTK_BUTTONBOX_END);
// parse script
char token[MAX_TOKEN];
const char *script = conf->layout;
parser_line = 1;
while (script = gettoken (script, token)) {
if (strcmp (token, "property")) {
fprintf (stderr, "invalid token while loading plugin %s config dialog: %s at line %d\n", conf->title, token, parser_line);
break;
}
char labeltext[MAX_TOKEN];
script = gettoken_warn_eof (script, labeltext);
if (!script) {
break;
}
if (ncurr > 0) {
pack[ncurr]--;
if (pack[ncurr] < 0) {
ncurr--;
}
}
char type[MAX_TOKEN];
script = gettoken_warn_eof (script, type);
if (!script) {
break;
}
if (!strncmp (type, "hbox[", 5) || !strncmp (type, "vbox[", 5)) {
ncurr++;
int n = 0;
if (1 != sscanf (type+4, "[%d]", &n)) {
break;
}
pack[ncurr] = n;
int vert = 0;
int hmg = FALSE;
int fill = FALSE;
int expand = FALSE;
int border = 0;
int spacing = 8;
int height = 100;
char param[MAX_TOKEN];
for (;;) {
script = gettoken_warn_eof (script, param);
if (!script) {
break;
}
if (!strcmp (param, ";")) {
break;
}
else if (!strcmp (param, "hmg")) {
hmg = TRUE;
}
else if (!strcmp (param, "fill")) {
fill = TRUE;
}
else if (!strcmp (param, "expand")) {
expand = TRUE;
}
else if (!strncmp (param, "border=", 7)) {
border = atoi (param+7);
}
else if (!strncmp (param, "spacing=", 8)) {
spacing = atoi (param+8);
}
else if (!strncmp (param, "height=", 7)) {
height = atoi (param+7);
}
}
widgets[ncurr] = vert ? gtk_vbox_new (TRUE, spacing) : gtk_hbox_new (TRUE, spacing);
gtk_widget_set_size_request (widgets[ncurr], -1, height);
gtk_widget_show (widgets[ncurr]);
gtk_box_pack_start (GTK_BOX(widgets[ncurr-1]), widgets[ncurr], fill, expand, border);
continue;
}
int vertical = 0;
char key[MAX_TOKEN];
for (;;) {
script = gettoken_warn_eof (script, key);
if (!script) {
break;
}
if (!strcmp (key, "vert")) {
vertical = 1;
}
else {
break;
}
}
char def[MAX_TOKEN];
script = gettoken_warn_eof (script, def);
if (!script) {
break;
}
// add to dialog
GtkWidget *label = NULL;
GtkWidget *prop = NULL;
GtkWidget *cont = NULL;
char value[1000];
conf->get_param (key, value, sizeof (value), def);
if (!strcmp (type, "entry") || !strcmp (type, "password")) {
label = gtk_label_new (_(labeltext));
gtk_widget_show (label);
prop = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (prop), TRUE);
g_signal_connect (G_OBJECT (prop), "changed", G_CALLBACK (prop_changed), win);
gtk_widget_show (prop);
gtk_entry_set_text (GTK_ENTRY (prop), value);
if (!strcmp (type, "password")) {
gtk_entry_set_visibility (GTK_ENTRY (prop), FALSE);
}
}
else if (!strcmp (type, "checkbox")) {
prop = gtk_check_button_new_with_label (_(labeltext));
g_signal_connect (G_OBJECT (prop), "toggled", G_CALLBACK (prop_changed), win);
gtk_widget_show (prop);
int val = atoi (value);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (prop), val);
}
else if (!strcmp (type, "file")) {
label = gtk_label_new (_(labeltext));
gtk_widget_show (label);
if (deadbeef->conf_get_int ("gtkui.pluginconf.use_filechooser_button", 0)) {
prop = gtk_file_chooser_button_new (_(labeltext), GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_widget_show (prop);
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (prop), value);
g_signal_connect (G_OBJECT (prop), "file-set", G_CALLBACK (prop_changed), win);
}
else {
cont = gtk_hbox_new (FALSE, 2);
gtk_widget_show (cont);
prop = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (prop), TRUE);
g_signal_connect (G_OBJECT (prop), "changed", G_CALLBACK (prop_changed), win);
gtk_widget_show (prop);
gtk_editable_set_editable (GTK_EDITABLE (prop), FALSE);
gtk_entry_set_text (GTK_ENTRY (prop), value);
gtk_box_pack_start (GTK_BOX (cont), prop, TRUE, TRUE, 0);
GtkWidget *btn = gtk_button_new_with_label ("…");
gtk_widget_show (btn);
gtk_box_pack_start (GTK_BOX (cont), btn, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (btn), "clicked", G_CALLBACK (on_prop_browse_file), prop);
}
}
else if (!strncmp (type, "select[", 7)) {
int n;
if (1 != sscanf (type+6, "[%d]", &n)) {
break;
}
label = gtk_label_new (_(labeltext));
gtk_widget_show (label);
prop = gtk_combo_box_text_new ();
gtk_widget_show (prop);
for (int i = 0; i < n; i++) {
char entry[MAX_TOKEN];
script = gettoken_warn_eof (script, entry);
if (!script) {
break;
}
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (prop), entry);
}
if (!script) {
break;
}
gtk_combo_box_set_active (GTK_COMBO_BOX (prop), atoi (value));
g_signal_connect ((gpointer) prop, "changed",
G_CALLBACK (prop_changed),
win);
}
else if (!strncmp (type, "hscale[", 7) || !strncmp (type, "vscale[", 7) || !strncmp (type, "spinbtn[", 8)) {
float min, max, step;
const char *args;
if (type[0] == 's') {
args = type + 7;
}
else {
args = type + 6;
}
if (3 != sscanf (args, "[%f,%f,%f]", &min, &max, &step)) {
break;
}
int invert = 0;
if (min >= max) {
float tmp = min;
min = max;
max = tmp;
invert = 1;
}
if (step <= 0) {
step = 1;
}
if (type[0] == 's') {
prop = gtk_spin_button_new_with_range (min, max, step);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (prop), atof (value));
}
else {
prop = type[0] == 'h' ? gtk_hscale_new_with_range (min, max, step) : gtk_vscale_new_with_range (min, max, step);
if (invert) {
gtk_range_set_inverted (GTK_RANGE (prop), TRUE);
}
gtk_range_set_value (GTK_RANGE (prop), (gdouble)atof (value));
gtk_scale_set_value_pos (GTK_SCALE (prop), GTK_POS_RIGHT);
}
label = gtk_label_new (_(labeltext));
gtk_widget_show (label);
g_signal_connect (G_OBJECT (prop), "value-changed", G_CALLBACK (prop_changed), win);
gtk_widget_show (prop);
}
script = gettoken_warn_eof (script, token);
if (!script) {
break;
}
if (strcmp (token, ";")) {
fprintf (stderr, "expected `;' while loading plugin %s config dialog: %s at line %d\n", conf->title, token, parser_line);
break;
}
if (label && prop) {
GtkWidget *hbox = NULL;
hbox = vertical ? gtk_vbox_new (FALSE, 8) : gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), cont ? cont : prop, TRUE, TRUE, 0);
cont = hbox;
}
else {
cont = prop;
}
if (prop) {
g_object_set_data (G_OBJECT (win), key, prop);
}
if (cont) {
gtk_box_pack_start (GTK_BOX (widgets[ncurr]), cont, FALSE, FALSE, 0);
}
}
int response;
do {
gtk_dialog_set_response_sensitive (GTK_DIALOG (win), GTK_RESPONSE_APPLY, FALSE);
response = gtk_dialog_run (GTK_DIALOG (win));
if (response == GTK_RESPONSE_APPLY || response == GTK_RESPONSE_OK) {
apply_conf (win, conf);
}
if (callback) {
int btn = ddb_button_from_gtk_response (response);
if (!callback (btn, ctx)) {
break;
}
}
} while (response == GTK_RESPONSE_APPLY);
gtk_widget_destroy (win);
int btn = ddb_button_from_gtk_response (response);
return btn;
}
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_acceptsFocus = TRUE;
m_needParent = TRUE;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxSlider creation failed") );
return FALSE;
}
m_oldPos = 0.0;
if (style & wxSL_VERTICAL)
m_widget = gtk_vscale_new( (GtkAdjustment *) NULL );
else
m_widget = gtk_hscale_new( (GtkAdjustment *) NULL );
if (style & wxSL_LABELS)
{
gtk_scale_set_draw_value( GTK_SCALE( m_widget ), TRUE );
gtk_scale_set_digits( GTK_SCALE( m_widget ), 0 );
/* labels need more space and too small window will
cause junk to appear on the dialog */
if (style & wxSL_VERTICAL)
{
wxSize sz( size );
if (sz.x < 35)
{
sz.x = 35;
SetSize( sz );
}
}
else
{
wxSize sz( size );
if (sz.y < 35)
{
sz.y = 35;
SetSize( sz );
}
}
}
else
gtk_scale_set_draw_value( GTK_SCALE( m_widget ), FALSE );
m_adjust = gtk_range_get_adjustment( GTK_RANGE(m_widget) );
#ifdef __WXGTK20__
if (style & wxSL_INVERSE)
gtk_range_set_inverted( GTK_RANGE(m_widget), TRUE );
#endif
GtkEnableEvents();
#ifdef __WXGTK20__
g_signal_connect (m_widget, "button_press_event",
G_CALLBACK (gtk_slider_button_press_callback),
this);
g_signal_connect (m_widget, "button_release_event",
G_CALLBACK (gtk_slider_button_release_callback),
this);
#endif
SetRange( minValue, maxValue );
SetValue( value );
m_parent->DoAddChild( this );
PostCreation(size);
return TRUE;
}
void gSlider::checkInverted()
{
gtk_range_set_inverted(GTK_RANGE(widget), !isVertical() && gDesktop::rightToLeft());
}
static GtkWidget *
garu_effects_init_box_equalizer (GaruEffects *self)
{
gint i;
gchar *text;
GtkWidget *vbox, *hbox, *grid, *label, *toogle, *combo_box, *scale;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
/* Label enabled */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
label = gtk_label_new (NULL);
text = garu_utils_text_bold (_("Enabled"));
gtk_label_set_markup (GTK_LABEL (label), text);
g_free (text);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
toogle = gtk_switch_new ();
g_settings_bind (self->settings, "equalizer-enabled",
toogle, "active", G_SETTINGS_BIND_DEFAULT);
gtk_box_pack_start (GTK_BOX (hbox), toogle, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/* ComboBox Presets */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 20);
label = gtk_label_new (_("Presets"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
combo_box = gtk_combo_box_text_new ();
for (i = 0 ; i < G_N_ELEMENTS (eq_presets); i++)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box),
eq_presets[i]);
gtk_box_pack_start (GTK_BOX (hbox), combo_box, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
g_settings_bind (self->settings, "equalizer-enabled",
hbox, "sensitive", G_SETTINGS_BIND_GET);
/* Grid equalizer */
grid = gtk_grid_new ();
for (i = 0; i < G_N_ELEMENTS (eq_bands); i++)
{
text = g_strdup_printf ("eq-custom-band%d", i);
scale = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
-12, 12, 0.1);
label = gtk_label_new (eq_bands [i]);
gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
gtk_scale_add_mark (GTK_SCALE (scale), 12.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 0.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), -12.0, GTK_POS_LEFT, NULL);
gtk_widget_set_size_request (scale, -1, 200);
gtk_grid_attach (GTK_GRID (grid), scale, i, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), label, i, 1, 1, 1);
g_signal_connect (scale, "value-changed",
G_CALLBACK (garu_effects_equalizer_scale_changed),
text);
self->eq_scales = g_slist_append (self->eq_scales, scale);
}
gtk_box_pack_start (GTK_BOX (vbox), grid, FALSE, FALSE, 0);
g_settings_bind (self->settings, "equalizer-enabled",
grid, "sensitive", G_SETTINGS_BIND_GET);
g_signal_connect (combo_box, "changed",
G_CALLBACK (garu_effects_equalizer_combo_box_changed),
self);
g_settings_bind (self->settings, "equalizer-preset",
combo_box, "active", G_SETTINGS_BIND_GET);
return vbox;
}
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;
}
NedMidiRecordConfigDialog::NedMidiRecordConfigDialog(GtkWindow *parent, int num, int denom, int midi_pgm,
int tempo_inverse, int volume, bool triplet, bool f_piano, bool dnt_split, int keysig) :
m_num(num), m_denom(denom), m_pgm(midi_pgm), m_tempo_inverse(tempo_inverse), m_metro_volume(volume), m_triplet(triplet), m_f_piano(f_piano), m_dnt_split(dnt_split), m_keysig(keysig) {
int i;
GtkWidget *dialog;
GtkWidget *time_signature_frame;
GtkWidget *numerator_label;
GtkWidget *denominator_label;
GtkWidget *time_signature_vbox;
GtkWidget *time_signature_upper_hbox;
GtkWidget *time_signature_lower_hbox;
GtkWidget *right_vbox;
GtkWidget *instrument_scroll;
GtkWidget *upper_hbox;
GtkListStore *instrumend_list_store;
GtkTreeIter iter;
GtkCellRenderer *instrument_renderer;
GtkTreeViewColumn *instrument_column;
GtkTreeViewColumn *instrument_num_column;
GtkTreePath* instrument_tree_path;
GtkWidget *tempo_frame;
GtkWidget *key_frame;
GtkWidget *key_frame_left_vbox;
GtkWidget *key_frame_right_vbox;
GtkWidget *radio_hbox;
GtkWidget *main_vbox;
GtkWidget *metro_volume_frame;
char Str[128];
dialog = gtk_dialog_new_with_buttons(_("Config Record"), parent, (GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
g_signal_connect(dialog, "response", G_CALLBACK (OnClose), (void *) this);
time_signature_frame = gtk_frame_new(_("time signature"));
time_signature_vbox = gtk_vbox_new(FALSE, 5);
time_signature_upper_hbox = gtk_hbox_new(FALSE, 5);
time_signature_lower_hbox = gtk_hbox_new(FALSE, 5);
numerator_label = gtk_label_new(_("Numerator:"));
denominator_label = gtk_label_new(_("Denominator:"));
m_numerator = gtk_spin_button_new_with_range (1.0, 20.0, 1.0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(m_numerator), m_num);
m_denominator = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(m_denominator), "2");
gtk_combo_box_append_text(GTK_COMBO_BOX(m_denominator), "4");
gtk_combo_box_append_text(GTK_COMBO_BOX(m_denominator), "8");
gtk_combo_box_append_text(GTK_COMBO_BOX(m_denominator), "16");
if (m_denom < 4) {
gtk_combo_box_set_active(GTK_COMBO_BOX(m_denominator), 0);
}
else if (m_denom < 8) {
gtk_combo_box_set_active(GTK_COMBO_BOX(m_denominator), 1);
}
else if (m_denom < 16) {
gtk_combo_box_set_active(GTK_COMBO_BOX(m_denominator), 2);
}
else {
gtk_combo_box_set_active(GTK_COMBO_BOX(m_denominator), 3);
}
gtk_box_pack_start (GTK_BOX (time_signature_upper_hbox), numerator_label, FALSE, FALSE, 0);
gtk_box_pack_end (GTK_BOX (time_signature_upper_hbox), m_numerator, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (time_signature_lower_hbox), denominator_label, FALSE, FALSE, 0);
gtk_box_pack_end (GTK_BOX (time_signature_lower_hbox), m_denominator, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (time_signature_vbox), time_signature_upper_hbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (time_signature_vbox), time_signature_lower_hbox, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER(time_signature_frame), time_signature_vbox);
m_with_triplet_button = gtk_toggle_button_new_with_label(_("triplet recognition"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_with_triplet_button), m_triplet);
m_force_piano_button = gtk_toggle_button_new_with_label(_("force piano"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_force_piano_button), m_f_piano);
m_dont_split_button = gtk_toggle_button_new_with_label(_("don't split tracks"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_dont_split_button), m_dnt_split);
if (m_dnt_split) {
gtk_widget_set_sensitive(m_force_piano_button, FALSE);
}
else if (m_f_piano) {
gtk_widget_set_sensitive(m_dont_split_button, FALSE);
}
g_signal_connect(m_force_piano_button, "toggled", G_CALLBACK (OnPianoForcePressed), (void *) this);
g_signal_connect(m_dont_split_button, "toggled", G_CALLBACK (OnDontSplitPressed), (void *) this);
right_vbox = gtk_vbox_new(FALSE, 5);
gtk_box_pack_start (GTK_BOX(right_vbox), time_signature_frame, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(right_vbox), m_with_triplet_button, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(right_vbox), m_force_piano_button, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(right_vbox), m_dont_split_button, FALSE, FALSE, 0);
instrumend_list_store = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING);
for (i = 0; i < NedResource::getNumInstruments(); i++) {
gtk_list_store_append (instrumend_list_store, &iter);
gtk_list_store_set (instrumend_list_store, &iter, 0, i, 1, gettext(NedResource::GM_Instruments[i]), -1);
}
m_instrument_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(instrumend_list_store));
instrument_renderer = gtk_cell_renderer_text_new ();
instrument_num_column = gtk_tree_view_column_new_with_attributes (_("no"), instrument_renderer, "text", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (m_instrument_list), instrument_num_column);
instrument_column = gtk_tree_view_column_new_with_attributes (_("instruments"), instrument_renderer, "text", 1, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (m_instrument_list), instrument_column);
m_instrument_adjustment = gtk_adjustment_new (0.0, 0.0, NedResource::getNumInstruments(), 1.0, 10.0, 10.0);
instrument_scroll = gtk_vscrollbar_new(GTK_ADJUSTMENT(m_instrument_adjustment));
gtk_tree_view_set_vadjustment (GTK_TREE_VIEW (m_instrument_list), GTK_ADJUSTMENT(m_instrument_adjustment));
gtk_widget_set_size_request(m_instrument_list, INSTRUMENTS_WIDGET_WIDTH, MIDI_RECORD_CONFIG_SHOW_WINDOW_HEIGHT);
sprintf(Str, "%d", m_pgm);
instrument_tree_path = gtk_tree_path_new_from_string(Str);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (m_instrument_list), instrument_tree_path, NULL, FALSE, 0.0, 0.0);
gtk_tree_view_set_cursor(GTK_TREE_VIEW (m_instrument_list), instrument_tree_path, NULL, FALSE);
g_signal_connect(dialog, "scroll-event", G_CALLBACK (OnScroll), (void *) this);
tempo_frame = gtk_frame_new(_("tempo"));
m_tempo_scale = gtk_vscale_new_with_range(0.1 * 60.0, 2.4 * 60.0, 0.4 * 60.0);
gtk_range_set_inverted(GTK_RANGE(m_tempo_scale), TRUE);
gtk_range_set_value(GTK_RANGE(m_tempo_scale), 60.0 * (double) m_tempo_inverse / 100000.0);
gtk_container_add (GTK_CONTAINER(tempo_frame), m_tempo_scale);
metro_volume_frame = gtk_frame_new(_("volume"));
m_metro_volume_scale = gtk_vscale_new_with_range(0.0, 127.0, 1.0);
gtk_range_set_inverted(GTK_RANGE(m_metro_volume_scale), TRUE);
gtk_range_set_value(GTK_RANGE(m_metro_volume_scale), m_metro_volume);
gtk_container_add (GTK_CONTAINER(metro_volume_frame), m_metro_volume_scale);
key_frame = gtk_frame_new(_("key"));
radio_hbox = gtk_hbox_new(FALSE, 2);
key_frame_left_vbox = gtk_vbox_new(FALSE, 2);
key_frame_right_vbox = gtk_vbox_new(FALSE, 2);
m_sig_radio_buttons[0] = gtk_radio_button_new_with_label (NULL, gettext(NedStaffContextDialog::m_keyTab[0]));
gtk_box_pack_start (GTK_BOX (key_frame_left_vbox), m_sig_radio_buttons[0], FALSE, FALSE, 0);
for (i = -5; i < 7; i++) {
m_sig_radio_buttons[i+6] = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (m_sig_radio_buttons[0]), gettext(NedStaffContextDialog::m_keyTab[i+6]));
if (i < 0) {
gtk_box_pack_start (GTK_BOX (key_frame_left_vbox), m_sig_radio_buttons[i+6], FALSE, FALSE, 0);
}
else {
gtk_box_pack_start (GTK_BOX (key_frame_right_vbox), m_sig_radio_buttons[i+6], FALSE, FALSE, 0);
}
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (m_sig_radio_buttons[keysig+6]), TRUE);
gtk_box_pack_start (GTK_BOX (radio_hbox), key_frame_left_vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (radio_hbox), key_frame_right_vbox, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER(key_frame), radio_hbox);
upper_hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start (GTK_BOX(upper_hbox), m_instrument_list, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX(upper_hbox), instrument_scroll, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(upper_hbox), right_vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(upper_hbox), tempo_frame, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(upper_hbox), metro_volume_frame, FALSE, FALSE, 0);
main_vbox = gtk_vbox_new(FALSE, 5);
gtk_box_pack_start (GTK_BOX(main_vbox), upper_hbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX(main_vbox), key_frame, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), main_vbox);
gtk_widget_show_all (dialog);
gtk_dialog_run(GTK_DIALOG(dialog));
}
osso_return_t
execute(osso_context_t *osso, gpointer data, gboolean user_activated)
{
/* Create needed variables */
GtkWidget *dialog;
GtkObject *adj[NUM_BANDS];
struct label_band *lband[NUM_BANDS];
struct dialog_and_sliders *dialog_slid;
GtkWidget *slider_band[NUM_BANDS];
GtkWidget *single_slider_container[NUM_BANDS];
gulong update_label_signal[NUM_BANDS];
gulong update_band_signal[NUM_BANDS];
GtkWidget *sliders_container;
gint i;
GtkWidget *toolbar;
GtkToolItem *toolitem_open;
GtkToolItem *toolitem_save_as;
GtkToolItem *toolitem_delete;
GtkWidget *content_area;
guint update_slider_signal;
dialog = gtk_dialog_new();
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
gtk_window_set_transient_for(GTK_WINDOW(dialog),
GTK_WINDOW(data));
gtk_window_set_title(GTK_WINDOW(dialog), "MAFW Equalizer");
gtk_window_set_default_size(GTK_WINDOW(dialog), -1, 400);
sliders_container = gtk_hbox_new(TRUE, 10);
toolbar = gtk_toolbar_new();
/* Create the bands */
for (i = 0; i < NUM_BANDS; i++) {
slider_band[i] = hildon_gtk_vscale_new();
adj[i] = gtk_adjustment_new(EQ_GAIN_MIN, EQ_GAIN_MIN,
EQ_GAIN_MAX, 1, 10, 0);
gtk_range_set_adjustment(GTK_RANGE(slider_band[i]),
GTK_ADJUSTMENT(adj[i]));
gtk_range_set_inverted(GTK_RANGE(slider_band[i]), TRUE);
gtk_range_set_update_policy(GTK_RANGE(slider_band[i]),
GTK_UPDATE_DELAYED);
gtk_range_set_show_fill_level(GTK_RANGE(slider_band[i]), FALSE);
single_slider_container[i] = gtk_hbox_new(TRUE, 0);
lband[i] = g_new0(struct label_band, 1);
lband[i]->label = gtk_label_new(NULL);
lband[i]->id = i;
gtk_label_set_angle(GTK_LABEL(lband[i]->label), 90);
gtk_misc_set_alignment(GTK_MISC(lband[i]->label), 0, 0.9);
gtk_box_pack_start(GTK_BOX(single_slider_container[i]),
lband[i]->label,
FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(single_slider_container[i]),
slider_band[i],
TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(sliders_container),
single_slider_container[i],
TRUE,
TRUE,
10);
update_label_signal[i] =
g_signal_connect(slider_band[i],
"value-changed",
G_CALLBACK(update_label_cb),
lband[i]);
gtk_range_set_value(GTK_RANGE(slider_band[i]),
get_band_value(i));
update_band_signal[i] =
g_signal_connect(slider_band[i],
"value-changed",
G_CALLBACK(update_band_cb),
GINT_TO_POINTER(i));
}
/* Listen for changes in gconf */
if (!confclient) {
confclient = gconf_client_get_default();
}
gconf_client_add_dir(confclient, GCONF_MAFW_GST_EQ_RENDERER,
GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
update_slider_signal =
gconf_client_notify_add(
confclient,
GCONF_MAFW_GST_EQ_RENDERER,
(GConfClientNotifyFunc) update_slider_cb,
slider_band,
NULL, NULL);
/* Create the toolbuttons */
toolitem_open = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
toolitem_save_as = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE_AS);
toolitem_delete = gtk_tool_button_new_from_stock(GTK_STOCK_DELETE);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem_open, -1);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem_save_as, -1);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem_delete, -1);
g_signal_connect(toolitem_open, "clicked",
G_CALLBACK(open_button_cb),
dialog);
g_signal_connect(toolitem_delete, "clicked",
G_CALLBACK(delete_button_cb),
dialog);
dialog_slid = g_new0(struct dialog_and_sliders, 1);
dialog_slid->dialog = dialog;
dialog_slid->slider_band = slider_band;
g_signal_connect(toolitem_save_as, "clicked",
G_CALLBACK(save_as_button_cb),
dialog_slid);
content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_box_pack_start(GTK_BOX(content_area), sliders_container,
TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX(content_area), toolbar,
FALSE, FALSE, 1);
/* Run the dialog */
gtk_widget_show_all(GTK_WIDGET(dialog));
gtk_dialog_run(GTK_DIALOG(dialog));
/* Free everything */
gconf_client_notify_remove(confclient, update_slider_signal);
for (i = 0; i < NUM_BANDS; i++) {
g_signal_handler_disconnect(slider_band[i],
update_label_signal[i]);
g_signal_handler_disconnect(slider_band[i],
update_band_signal[i]);
g_free(lband[i]);
}
g_free(dialog_slid);
gtk_widget_destroy(GTK_WIDGET(dialog));
return OSSO_OK;
}
static void
gst_switch_ptz_init (GstSwitchPTZ * ptz)
{
GtkWidget *box_main, *box_video, *box_control;
GtkWidget *box_control_pan, *box_control_tilt, *box_control_zoom;
GtkWidget *scale_pan, *scale_tilt, *control_grid, *box_buttons_tilt;
GtkWidget *control_buttons[3][3] = { {NULL} };
GtkWidget *box_zoom, *zoom_minus, *zoom_reset, *zoom_plus;
GtkWidget *scrollwin;
GtkWidget *scale_zoom;
GtkWidget *scale_pan_speed, *scale_tilt_speed, *scale_zoom_speed;
GtkWidget *label_pan_speed, *label_tilt_speed, *label_zoom_speed;
GtkWidget *label;
const gchar *control_labels[3][3] = {
/*
{" \\ ", " ^ ", " / "},
{" < ", " * ", " > "},
{" / ", " v ", " \\ "},
*/
/*
{ " \\ ", GTK_STOCK_GO_UP, " / " },
{ GTK_STOCK_GO_BACK, GTK_STOCK_HOME, GTK_STOCK_GO_FORWARD },
{ " / ", GTK_STOCK_GO_DOWN, " \\ " },
*/
{"icons/up_left.png", "icons/up.png", "icons/up_right.png"},
{"icons/left.png", "icons/center.png", "icons/right.png"},
{"icons/down_left.png", "icons/down.png", "icons/down_right.png"},
};
int n, m;
const char *title = NULL;
ptz->controller = gst_cam_controller_new (ptz_control_protocol);
if (ptz->controller == NULL) {
return;
}
gst_cam_controller_open (ptz->controller, ptz_device_name);
title = ptz->controller->device_info;
if (title == NULL)
title = "??? - PTZ Controller";
ptz->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (ptz->window), 640, 480);
gtk_window_set_title (GTK_WINDOW (ptz->window), title);
g_signal_connect (G_OBJECT (ptz->window), "delete-event",
G_CALLBACK (gst_switch_ptz_window_closed), ptz);
box_main = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
box_video = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
box_control = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
scrollwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (scrollwin, 200, -1);
gtk_widget_set_vexpand (scrollwin, TRUE);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrollwin),
box_control);
gtk_box_pack_start (GTK_BOX (box_main), box_video, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box_main), scrollwin, FALSE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (ptz->window), box_main);
gtk_container_set_border_width (GTK_CONTAINER (ptz->window), 5);
ptz->video_view = gtk_drawing_area_new ();
gtk_widget_set_name (ptz->video_view, "video");
gtk_widget_set_double_buffered (ptz->video_view, FALSE);
gtk_widget_set_hexpand (ptz->video_view, TRUE);
gtk_widget_set_vexpand (ptz->video_view, TRUE);
gtk_widget_set_events (ptz->video_view, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
gtk_box_pack_start (GTK_BOX (box_video), ptz->video_view, TRUE, TRUE, 0);
scale_pan =
gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
ptz->controller->pan_min, ptz->controller->pan_max, 1.0);
scale_tilt =
gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
ptz->controller->tilt_min, ptz->controller->tilt_max, 1.0);
//gtk_range_set_slider_size_fixed (GTK_RANGE (scale_pan), TRUE);
gtk_widget_set_size_request (scale_pan, 300, -1);
gtk_scale_set_value_pos (GTK_SCALE (scale_pan), GTK_POS_RIGHT);
gtk_scale_set_value_pos (GTK_SCALE (scale_tilt), GTK_POS_BOTTOM);
gtk_range_set_inverted (GTK_RANGE (scale_tilt), TRUE);
ptz->adjust_pan = gtk_range_get_adjustment (GTK_RANGE (scale_pan));
ptz->adjust_tilt = gtk_range_get_adjustment (GTK_RANGE (scale_tilt));
g_signal_connect (gtk_range_get_adjustment (GTK_RANGE (scale_pan)),
"value-changed", G_CALLBACK (gst_switch_ptz_pan_changed), ptz);
g_signal_connect (gtk_range_get_adjustment (GTK_RANGE (scale_tilt)),
"value-changed", G_CALLBACK (gst_switch_ptz_tilt_changed), ptz);
control_grid = gtk_grid_new ();
gtk_grid_insert_row (GTK_GRID (control_grid), 0);
gtk_grid_insert_row (GTK_GRID (control_grid), 1);
gtk_grid_insert_row (GTK_GRID (control_grid), 2);
gtk_grid_insert_column (GTK_GRID (control_grid), 0);
gtk_grid_insert_column (GTK_GRID (control_grid), 1);
gtk_grid_insert_column (GTK_GRID (control_grid), 2);
for (n = 0; n < 3; ++n) {
for (m = 0; m < 3; ++m) {
GtkWidget *btn = control_buttons[m][n] = gtk_button_new ();
gtk_grid_attach (GTK_GRID (control_grid), btn, n, m, 1, 1);
gtk_widget_set_size_request (btn, 70, 70);
gtk_button_set_image (GTK_BUTTON (btn),
gtk_image_new_from_file (control_labels[m][n]));
}
}
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), "<b>Pan/Tilt:</b>");
box_buttons_tilt = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (box_control), label, TRUE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (box_control), scale_pan, FALSE, TRUE, 10);
gtk_box_pack_start (GTK_BOX (box_buttons_tilt), scale_tilt, FALSE, TRUE, 10);
gtk_box_pack_start (GTK_BOX (box_buttons_tilt), control_grid, FALSE, TRUE,
10);
gtk_box_pack_start (GTK_BOX (box_control), box_buttons_tilt, FALSE, TRUE, 10);
gtk_box_pack_start (GTK_BOX (box_control), gtk_label_new (""), TRUE, TRUE,
10);
box_zoom = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
zoom_minus = gtk_button_new ();
zoom_reset = gtk_button_new ();
zoom_plus = gtk_button_new ();
gtk_button_set_image (GTK_BUTTON (zoom_minus),
gtk_image_new_from_file ("icons/zoom_out.png"));
gtk_button_set_image (GTK_BUTTON (zoom_reset),
gtk_image_new_from_file ("icons/zoom.png"));
gtk_button_set_image (GTK_BUTTON (zoom_plus),
gtk_image_new_from_file ("icons/zoom_in.png"));
gtk_widget_set_size_request (zoom_minus, 70, 70);
gtk_widget_set_size_request (zoom_reset, 70, 70);
gtk_widget_set_size_request (zoom_plus, 70, 70);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), "<b>Zoom:</b>");
gtk_box_pack_start (GTK_BOX (box_control), label, TRUE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (box_zoom), gtk_label_new (""), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box_zoom), zoom_minus, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (box_zoom), zoom_reset, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (box_zoom), zoom_plus, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (box_zoom), gtk_label_new (""), TRUE, TRUE, 10);
scale_zoom =
gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 1.0, 0.01);
gtk_range_set_value (GTK_RANGE (scale_zoom), 0.5);
ptz->adjust_zoom = gtk_range_get_adjustment (GTK_RANGE (scale_zoom));
label = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (label), scale_zoom, TRUE, TRUE, 10);
gtk_box_pack_start (GTK_BOX (box_control), label, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (box_control), box_zoom, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (box_control), gtk_label_new (""), TRUE, TRUE,
10);
g_signal_connect (zoom_minus, "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_zoom_minus), ptz);
g_signal_connect (zoom_reset, "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_zoom_reset), ptz);
g_signal_connect (zoom_plus, "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_zoom_plus), ptz);
g_signal_connect (zoom_minus, "released",
G_CALLBACK (gst_switch_ptz_button_released_zoom_minus), ptz);
g_signal_connect (zoom_plus, "released",
G_CALLBACK (gst_switch_ptz_button_released_zoom_plus), ptz);
scale_pan_speed =
gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
ptz->controller->pan_speed_min, ptz->controller->pan_speed_max, 1.0);
scale_tilt_speed =
gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
ptz->controller->tilt_speed_min, ptz->controller->tilt_speed_max, 1.0);
scale_zoom_speed =
gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 1.0, 0.01);
gtk_range_set_value (GTK_RANGE (scale_pan_speed),
ptz->controller->pan_speed_max);
gtk_range_set_value (GTK_RANGE (scale_tilt_speed),
ptz->controller->tilt_speed_max);
gtk_range_set_value (GTK_RANGE (scale_zoom_speed), 1.0);
ptz->adjust_pan_speed =
gtk_range_get_adjustment (GTK_RANGE (scale_pan_speed));
ptz->adjust_tilt_speed =
gtk_range_get_adjustment (GTK_RANGE (scale_tilt_speed));
ptz->adjust_zoom_speed =
gtk_range_get_adjustment (GTK_RANGE (scale_zoom_speed));
label_pan_speed = gtk_label_new ("");
label_tilt_speed = gtk_label_new ("");
label_zoom_speed = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label_pan_speed), "<b>P:</b>");
gtk_label_set_markup (GTK_LABEL (label_tilt_speed), "<b>T:</b>");
gtk_label_set_markup (GTK_LABEL (label_zoom_speed), "<b>Z:</b>");
box_control_pan = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
box_control_tilt = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
box_control_zoom = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), "<b>Speeds:</b>");
gtk_box_pack_start (GTK_BOX (box_control), label, FALSE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (box_control_pan), label_pan_speed, FALSE, FALSE,
0);
gtk_box_pack_start (GTK_BOX (box_control_pan), scale_pan_speed, TRUE, TRUE,
10);
gtk_box_pack_start (GTK_BOX (box_control_tilt), label_tilt_speed, FALSE,
FALSE, 0);
gtk_box_pack_start (GTK_BOX (box_control_tilt), scale_tilt_speed, TRUE, TRUE,
10);
gtk_box_pack_start (GTK_BOX (box_control_zoom), label_zoom_speed, FALSE,
FALSE, 0);
gtk_box_pack_start (GTK_BOX (box_control_zoom), scale_zoom_speed, TRUE, TRUE,
10);
gtk_box_pack_start (GTK_BOX (box_control), box_control_pan, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box_control), box_control_tilt, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box_control), box_control_zoom, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box_control), gtk_label_new (""), TRUE, TRUE,
10);
{
double v, tick = 50;
gchar *s;
gchar buf[64] = { 0 };
int n;
const gchar *fmt = "<small><sub>%d</sub></small>";
const gchar *fmtb = "<small><sub><b>%d</b></sub></small>";
g_sprintf ((s = buf), fmtb, 0);
gtk_scale_add_mark (GTK_SCALE (scale_pan), 0, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) ptz->controller->pan_min);
gtk_scale_add_mark (GTK_SCALE (scale_pan), ptz->controller->pan_min,
GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) ptz->controller->pan_max);
gtk_scale_add_mark (GTK_SCALE (scale_pan), ptz->controller->pan_max,
GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, 0);
gtk_scale_add_mark (GTK_SCALE (scale_tilt), 0, GTK_POS_RIGHT, s);
g_sprintf ((s = buf), fmtb, (int) ptz->controller->tilt_min);
gtk_scale_add_mark (GTK_SCALE (scale_tilt), ptz->controller->tilt_min,
GTK_POS_RIGHT, s);
g_sprintf ((s = buf), fmtb, (int) ptz->controller->tilt_max);
gtk_scale_add_mark (GTK_SCALE (scale_tilt), ptz->controller->tilt_max,
GTK_POS_RIGHT, s);
for (v = -tick; ptz->controller->pan_min <= v; v -= tick) {
if (v - ptz->controller->pan_min < 1)
continue;
n = (int) v;
s = NULL;
if (abs (n) % 50 == 0)
g_sprintf ((s = buf), fmt, n);
gtk_scale_add_mark (GTK_SCALE (scale_pan), v, GTK_POS_BOTTOM, s);
}
for (v = tick; v <= ptz->controller->pan_max; v += tick) {
if (ptz->controller->pan_max - v < 1)
continue;
n = (int) v;
s = NULL;
if (abs (n) % 50 == 0)
g_sprintf ((s = buf), fmt, n);
gtk_scale_add_mark (GTK_SCALE (scale_pan), v, GTK_POS_BOTTOM, s);
}
for (v = -tick; ptz->controller->tilt_min <= v; v -= tick) {
if (v - ptz->controller->tilt_min < 1)
continue;
n = (int) v;
s = NULL;
if (abs (n) % 50 == 0)
g_sprintf ((s = buf), fmt, n);
gtk_scale_add_mark (GTK_SCALE (scale_tilt), v, GTK_POS_RIGHT, s);
}
for (v = tick; v <= ptz->controller->tilt_max; v += tick) {
if (ptz->controller->tilt_max - v < 1)
continue;
n = (int) v;
s = NULL;
if (abs (n) % 50 == 0)
g_sprintf ((s = buf), fmt, n);
gtk_scale_add_mark (GTK_SCALE (scale_tilt), v, GTK_POS_RIGHT, s);
}
g_sprintf ((s = buf), fmtb, (int) (v =
ptz->controller->pan_speed_min + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_pan_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) (v =
ptz->controller->pan_speed_max + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_pan_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) (v =
(ptz->controller->pan_speed_max -
ptz->controller->pan_speed_min) / 2 + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_pan_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) (v =
ptz->controller->tilt_speed_min + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_tilt_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) (v =
ptz->controller->tilt_speed_max + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_tilt_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) (v =
(ptz->controller->tilt_speed_max -
ptz->controller->tilt_speed_min) / 2 + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_tilt_speed), v, GTK_POS_BOTTOM, s);
fmtb = "<small><sub><b>%.1f</b></sub></small>";
g_sprintf ((s = buf), fmtb, (v = 0.0));
gtk_scale_add_mark (GTK_SCALE (scale_zoom_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (v = 1.0));
gtk_scale_add_mark (GTK_SCALE (scale_zoom_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (v = 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_zoom_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (v = 0.0));
gtk_scale_add_mark (GTK_SCALE (scale_zoom), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (v = 1.0));
gtk_scale_add_mark (GTK_SCALE (scale_zoom), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (v = 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_zoom), v, GTK_POS_BOTTOM, s);
}
if (strcmp (ptz_control_protocol, "visca-sony") == 0) {
gtk_widget_set_sensitive (box_control_pan, FALSE);
gtk_widget_set_sensitive (box_control_tilt, FALSE);
gtk_widget_set_sensitive (box_control_zoom, FALSE);
}
/*
g_signal_connect (G_OBJECT (scale_pan_speed), "value-changed",
G_CALLBACK (gst_switch_ptz_window_closed), ptz);
*/
g_signal_connect (ptz->adjust_pan_speed, "value-changed",
G_CALLBACK (gst_switch_ptz_pan_speed_changed), ptz);
g_signal_connect (ptz->adjust_tilt_speed, "value-changed",
G_CALLBACK (gst_switch_ptz_tilt_speed_changed), ptz);
g_signal_connect (ptz->adjust_zoom_speed, "value-changed",
G_CALLBACK (gst_switch_ptz_zoom_speed_changed), ptz);
g_signal_connect (ptz->adjust_zoom, "value-changed",
G_CALLBACK (gst_switch_ptz_zoom_changed), ptz);
g_signal_connect (control_buttons[0][0], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_left_top), ptz);
g_signal_connect (control_buttons[0][1], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_top), ptz);
g_signal_connect (control_buttons[0][2], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_top_right), ptz);
g_signal_connect (control_buttons[1][0], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_left), ptz);
g_signal_connect (control_buttons[1][1], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_center), ptz);
g_signal_connect (control_buttons[1][2], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_right), ptz);
g_signal_connect (control_buttons[2][0], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_bottom_left), ptz);
g_signal_connect (control_buttons[2][1], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_bottom), ptz);
g_signal_connect (control_buttons[2][2], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_right_bottom), ptz);
g_signal_connect (control_buttons[0][0], "released",
G_CALLBACK (gst_switch_ptz_button_released_left_top), ptz);
g_signal_connect (control_buttons[0][1], "released",
G_CALLBACK (gst_switch_ptz_button_released_top), ptz);
g_signal_connect (control_buttons[0][2], "released",
G_CALLBACK (gst_switch_ptz_button_released_top_right), ptz);
g_signal_connect (control_buttons[1][0], "released",
G_CALLBACK (gst_switch_ptz_button_released_left), ptz);
g_signal_connect (control_buttons[1][2], "released",
G_CALLBACK (gst_switch_ptz_button_released_right), ptz);
g_signal_connect (control_buttons[2][0], "released",
G_CALLBACK (gst_switch_ptz_button_released_bottom_left), ptz);
g_signal_connect (control_buttons[2][1], "released",
G_CALLBACK (gst_switch_ptz_button_released_bottom), ptz);
g_signal_connect (control_buttons[2][2], "released",
G_CALLBACK (gst_switch_ptz_button_released_right_bottom), ptz);
do_update = TRUE;
gst_switch_ptz_update_xy (ptz);
do_update = FALSE;
g_timeout_add (300, (GSourceFunc) gst_switch_ptz_update, ptz);
g_timeout_add (100, (GSourceFunc) gst_switch_ptz_update_xy, ptz);
//g_timeout_add (50, (GSourceFunc) gst_switch_ptz_update_d, ptz);
}
GtkWidget *
mate_volume_applet_dock_new (GtkOrientation orientation,
MateVolumeApplet *parent)
{
/* FIXME: Remove the orientation argument, or fix it for vertical
boxes (a "horizontal" orientation - the meaning is reversed for
historical reasons. */
GtkWidget *button, *scale, *mute, *more, *label;
GtkWidget *container, *outerline, *innerline, *frame;
MateVolumeAppletDock *dock;
gint i;
static struct {
GtkWidget * (* sfunc) (GtkAdjustment *adj);
GtkWidget * (* container) (gboolean, gint);
GtkWidget * (* subcontainer) (gboolean, gint);
gint sw, sh;
gboolean inverted;
} magic[2] = {
{ gtk_vscale_new, gtk_hbox_new, gtk_vbox_new, -1, 200, TRUE},
{ gtk_hscale_new, gtk_vbox_new, gtk_hbox_new, 200, -1, FALSE}
};
dock = g_object_new (MATE_VOLUME_APPLET_TYPE_DOCK,
NULL);
gtk_window_set_screen (GTK_WINDOW (dock),
gtk_widget_get_screen(GTK_WIDGET (parent)));
dock->orientation = orientation;
dock->model = parent;
g_signal_connect (dock, "key_press_event", G_CALLBACK (cb_key_press),
NULL);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
gtk_container_add (GTK_CONTAINER (dock), frame);
container = magic[orientation].container (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (container), 6);
gtk_container_add (GTK_CONTAINER (frame), container);
outerline = magic[orientation].subcontainer (FALSE, 0);
innerline = magic[orientation].subcontainer (FALSE, 0);
gtk_box_pack_start (GTK_BOX (container), outerline, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (container), innerline, FALSE, FALSE, 0);
dock->minus = GTK_BUTTON (gtk_button_new ());
gtk_box_pack_start (GTK_BOX (outerline), GTK_WIDGET (dock->minus),
FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (dock->minus),
gtk_image_new_from_stock (GTK_STOCK_REMOVE,
GTK_ICON_SIZE_BUTTON));
dock->plus = GTK_BUTTON (gtk_button_new ());
gtk_box_pack_end (GTK_BOX (outerline), GTK_WIDGET (dock->plus),
FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (dock->plus),
gtk_image_new_from_stock (GTK_STOCK_ADD,
GTK_ICON_SIZE_BUTTON));
button = GTK_WIDGET (dock->plus);
for (i = 0; i<2; i++) { /* For button in (dock->plus, dock->minus): */
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
g_signal_connect (button, "button-press-event",
G_CALLBACK (cb_button_press), dock);
g_signal_connect (button, "button-release-event",
G_CALLBACK (cb_button_release), dock);
button = GTK_WIDGET (dock->minus);
}
scale = magic[orientation].sfunc (NULL);
g_signal_connect (scale, "key-press-event", G_CALLBACK (proxy_key_event),
parent);
g_signal_connect (scale, "scroll-event", G_CALLBACK (proxy_scroll_event),
parent);
dock->scale = GTK_RANGE (scale);
gtk_widget_set_size_request (scale,
magic[orientation].sw,
magic[orientation].sh);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_range_set_inverted (dock->scale, magic[orientation].inverted);
gtk_box_pack_start (GTK_BOX (outerline), GTK_WIDGET (dock->scale),
TRUE, TRUE, 0);
dock->mute = gtk_check_button_new_with_label (_("Mute"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dock->mute),
mixer_is_muted (dock->model));
g_signal_connect (dock->mute, "toggled", G_CALLBACK (mute_cb), dock);
gtk_box_pack_start (GTK_BOX (innerline), dock->mute, TRUE, TRUE, 0);
more = gtk_button_new_with_label (_("Volume Control..."));
g_signal_connect (more, "clicked", G_CALLBACK (launch_mixer_cb), dock);
gtk_box_pack_end (GTK_BOX (innerline), more, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (dock), frame);
return GTK_WIDGET (dock);
}
