void cb_draw_value( GtkToggleButton *button )
{
/* Turn the value display on the scale widgets off or on depending
* on the state of the checkbutton */
gtk_scale_set_draw_value (GTK_SCALE (hscale), button->active);
gtk_scale_set_draw_value (GTK_SCALE (vscale), button->active);
}
void ColorOptionView::_createItem() {
const ZLColor &color = ((ZLColorOptionEntry*)myOption)->color();
myDrawingArea = gtk_drawing_area_new();
gtk_widget_set_size_request(GTK_WIDGET(myDrawingArea), 60, 20);
// myWidget = gtk_button_new();
// gtk_container_add(GTK_CONTAINER(myWidget), myDrawingArea);
// g_signal_connect(G_OBJECT(myWidget), "clicked", G_CALLBACK(_onChangeColor), this);
myWidget = gtk_table_new(3, 4, false);
gtk_table_attach(GTK_TABLE(myWidget), gtk_label_new(""), 0, 3, 0, 1, (GtkAttachOptions)(GTK_FILL|GTK_SHRINK), (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), 0, 0);
gtk_table_attach(GTK_TABLE(myWidget), gtk_label_new("Red"), 0, 1, 1, 2, (GtkAttachOptions)(GTK_FILL|GTK_SHRINK), (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), 0, 0);
gtk_table_attach(GTK_TABLE(myWidget), gtk_label_new("Green"), 0, 1, 2, 3, (GtkAttachOptions)(GTK_FILL|GTK_SHRINK), (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), 0, 0);
gtk_table_attach(GTK_TABLE(myWidget), gtk_label_new("Blue"), 0, 1, 3, 4, (GtkAttachOptions)(GTK_FILL|GTK_SHRINK), (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), 0, 0);
myRSlider = gtk_hscale_new_with_range(0.0, 255.0, 1.0);
gtk_scale_set_draw_value(GTK_SCALE(myRSlider), false);
gtk_range_set_value(GTK_RANGE(myRSlider), color.Red);
g_signal_connect(G_OBJECT(myRSlider), "value-changed", G_CALLBACK(_onSliderMove), this);
myGSlider = gtk_hscale_new_with_range(0.0, 255.0, 1.0);
gtk_scale_set_draw_value(GTK_SCALE(myGSlider), false);
gtk_range_set_value(GTK_RANGE(myGSlider), color.Green);
g_signal_connect(G_OBJECT(myGSlider), "value-changed", G_CALLBACK(_onSliderMove), this);
myBSlider = gtk_hscale_new_with_range(0.0, 255.0, 1.0);
gtk_scale_set_draw_value(GTK_SCALE(myBSlider), false);
gtk_range_set_value(GTK_RANGE(myBSlider), color.Blue);
g_signal_connect(G_OBJECT(myBSlider), "value-changed", G_CALLBACK(_onSliderMove), this);
gtk_table_attach_defaults(GTK_TABLE(myWidget), myRSlider, 1, 2, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(myWidget), myGSlider, 1, 2, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(myWidget), myBSlider, 1, 2, 3, 4);
myColor.red = color.Red * 65535 / 255;
myColor.blue = color.Blue * 65535 / 255;
myColor.green = color.Green * 65535 / 255;
gtk_widget_modify_bg(myDrawingArea, GTK_STATE_NORMAL, &myColor);
GtkWidget *frame = gtk_frame_new(NULL);
gtk_container_add(GTK_CONTAINER(frame), myDrawingArea);
gtk_table_attach(GTK_TABLE(myWidget), frame, 2, 3, 1, 4, (GtkAttachOptions)(GTK_FILL|GTK_SHRINK), (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), 0, 0);
gtk_table_set_col_spacings(GTK_TABLE(myWidget), 2);
gtk_table_set_row_spacings(GTK_TABLE(myWidget), 2);
gtk_widget_show_all(myWidget);
myTab->addItem(myWidget, myRow, myFromColumn, myToColumn);
}
static GObject *
gam_slider_pan_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_params)
{
GObject *object;
GamSliderPan *gam_slider_pan;
GamSliderPanPrivate *priv;
object = (* G_OBJECT_CLASS (parent_class)->constructor) (type,
n_construct_properties,
construct_params);
gam_slider_pan = GAM_SLIDER_PAN (object);
priv = GAM_SLIDER_PAN_GET_PRIVATE (gam_slider_pan);
if (!snd_mixer_selem_is_playback_mono (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan)))) {
priv->pan_adjustment = gtk_adjustment_new (gam_slider_pan_get_pan (gam_slider_pan), -100, 101, 1, 5, 1);
g_signal_connect (G_OBJECT (priv->pan_adjustment), "value-changed",
G_CALLBACK (gam_slider_pan_pan_value_changed_cb), gam_slider_pan);
priv->pan_slider = gtk_hscale_new (GTK_ADJUSTMENT (priv->pan_adjustment));
gtk_scale_set_draw_value (GTK_SCALE (priv->pan_slider), FALSE);
g_signal_connect (G_OBJECT (priv->pan_slider), "event",
G_CALLBACK (gam_slider_pan_pan_event_cb), gam_slider_pan);
} else
priv->pan_slider = gtk_label_new (NULL);
gtk_widget_show (priv->pan_slider);
gam_slider_add_pan_widget (GAM_SLIDER (gam_slider_pan), priv->pan_slider);
priv->vol_adjustment = gtk_adjustment_new (gam_slider_pan_get_volume (gam_slider_pan), 0, 101, 1, 5, 1);
g_signal_connect (G_OBJECT (priv->vol_adjustment), "value-changed",
G_CALLBACK (gam_slider_pan_volume_value_changed_cb), gam_slider_pan);
priv->vol_slider = gtk_vscale_new (GTK_ADJUSTMENT (priv->vol_adjustment));
gtk_widget_show (priv->vol_slider);
gtk_scale_set_draw_value (GTK_SCALE (priv->vol_slider), FALSE);
gam_slider_add_volume_widget (GAM_SLIDER (gam_slider_pan), priv->vol_slider);
gtk_label_set_mnemonic_widget (gam_slider_get_label_widget (GAM_SLIDER (gam_slider_pan)),
priv->vol_slider);
return object;
}
/* greebo: This adds a horizontal slider and connects it to the value of the given registryKey
*/
void Dialog::addSlider (GtkWidget* vbox, const std::string& name, const std::string& registryKey,
gboolean draw_value, double value, double lower, double upper,
double step_increment, double page_increment, double page_size)
{
// Create a new adjustment with the boundaries <lower> and <upper> and all the increments
GtkObject* adj = gtk_adjustment_new(value, lower, upper, step_increment, page_increment, page_size);
// Connect the registry key to this adjustment
_registryConnector.connectGtkObject(adj, registryKey);
// scale
GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 1.0, 0.0);
gtk_widget_show(alignment);
GtkWidget* scale = gtk_hscale_new(GTK_ADJUSTMENT(adj));
gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_LEFT);
gtk_widget_show(scale);
gtk_container_add(GTK_CONTAINER(alignment), scale);
gtk_scale_set_draw_value(GTK_SCALE (scale), draw_value);
int digits = (step_increment < 1.0f) ? 2 : 0;
gtk_scale_set_digits(GTK_SCALE (scale), digits);
GtkTable* row = DialogRow_new(name, alignment);
DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
}
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);
}
static GtkWidget*
gimp_scale_entry_new (GtkWidget *parent_box,
gfloat value,
gfloat lower,
gfloat upper,
gfloat step_increment,
gfloat page_increment)
{
GtkWidget *hbox;
GtkWidget *scale;
GtkWidget *spinbutton;
GtkObject *adj;
adj = gtk_adjustment_new (value, lower, upper,
step_increment, page_increment,
0.0);
spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1.0, 0);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adj));
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
gtk_widget_set_size_request (GTK_WIDGET (scale), SCALE_SIZE, -1);
hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (parent_box), hbox, TRUE, TRUE, 0);
gtk_widget_show_all (hbox);
return scale;
}
static void
hildon_vvolumebar_init (HildonVVolumebar *vvolumebar)
{
HildonVolumebarPrivate *priv;
priv = HILDON_VOLUMEBAR_GET_PRIVATE (vvolumebar);
g_assert (priv);
priv->volumebar = HILDON_VOLUMEBAR_RANGE (hildon_volumebar_range_new
(GTK_ORIENTATION_VERTICAL));
gtk_widget_set_parent (GTK_WIDGET (priv->tbutton), GTK_WIDGET (vvolumebar));
gtk_widget_set_parent (GTK_WIDGET (priv->volumebar), GTK_WIDGET (vvolumebar));
gtk_scale_set_draw_value (GTK_SCALE (priv->volumebar), FALSE);
/* Signals */
g_signal_connect_swapped(G_OBJECT(priv->volumebar), "value-changed",
G_CALLBACK(hildon_volumebar_level_change),
vvolumebar);
g_signal_connect_swapped(priv->tbutton, "toggled",
G_CALLBACK(hildon_volumebar_mute_toggled), vvolumebar);
/* FIXME Not sure why this is here */
gtk_widget_show (GTK_WIDGET (priv->volumebar));
}
static GtkWidget * create_slider (const char * name, int band)
{
GtkWidget * vbox, * slider, * label;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
label = gtk_label_new (name);
gtk_label_set_angle ((GtkLabel *) label, 90);
gtk_box_pack_start ((GtkBox *) vbox, label, TRUE, FALSE, 0);
slider = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
-EQUALIZER_MAX_GAIN, EQUALIZER_MAX_GAIN, 1);
gtk_scale_set_draw_value ((GtkScale *) slider, TRUE);
gtk_scale_set_value_pos ((GtkScale *) slider, GTK_POS_BOTTOM);
gtk_widget_set_size_request (slider, -1, 120);
g_object_set_data ((GObject *) slider, "band", GINT_TO_POINTER (band));
g_signal_connect ((GObject *) slider, "format-value", (GCallback) format_value, NULL);
g_signal_connect ((GObject *) slider, "value-changed", (GCallback) slider_moved, NULL);
slider_update (NULL, (GtkRange *) slider);
if (band == -1)
hook_associate ("set equalizer_preamp", (HookFunction) slider_update, slider);
else
hook_associate ("set equalizer_bands", (HookFunction) slider_update, slider);
gtk_box_pack_start ((GtkBox *) vbox, slider, FALSE, FALSE, 0);
return vbox;
}
gboolean
headerbarui_update_seekbar_cb(gpointer user_data)
{
if (seekbar_ismoving) return TRUE;
DB_playItem_t *trk = deadbeef->streamer_get_playing_track ();
if (!trk || deadbeef->pl_get_item_duration (trk) < 0) {
if (trk) {
deadbeef->pl_item_unref (trk);
}
headerbarui_reset_cb(NULL);
return TRUE;
}
if (deadbeef->pl_get_item_duration (trk) > 0) {
GtkAdjustment * adjustment = gtk_range_get_adjustment(GTK_RANGE (headerbar_seekbar));
gtk_adjustment_configure(adjustment,
deadbeef->streamer_get_playpos (), //value
0, // lower
deadbeef->pl_get_item_duration (trk), // upper
1, // step_increment
1, // page_increment
0); // page_size
gtk_scale_set_draw_value(GTK_SCALE(headerbar_seekbar), TRUE);
}
if (trk) {
deadbeef->pl_item_unref (trk);
}
return TRUE;
}
void
gui_subs_create_slider (GtkBox *destbox,
gui_subs_slider *s)
{
GtkWidget *thing, *box;
box = gtk_hbox_new(FALSE, 4);
gtk_widget_show(box);
gtk_box_pack_start(destbox, box, FALSE, TRUE, 0);
thing = gtk_label_new(s->title);
gtk_widget_show(thing);
gtk_box_pack_start(GTK_BOX(box), thing, FALSE, TRUE, 0);
s->adjustment1 = GTK_ADJUSTMENT(gtk_adjustment_new(s->min, s->min, s->max, 1, (s->max - s->min) / 10, 0));
s->slider = gtk_hscale_new(s->adjustment1);
gtk_scale_set_draw_value(GTK_SCALE(s->slider), FALSE);
gtk_widget_show(s->slider);
gtk_box_pack_start(GTK_BOX(box), s->slider, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT(s->adjustment1), "value_changed",
GTK_SIGNAL_FUNC(gui_subs_slider_update_1), s);
s->adjustment2 = GTK_ADJUSTMENT(gtk_adjustment_new(s->min, s->min, s->max, 1, (s->max - s->min) / 10, 0));
thing = gtk_spin_button_new(s->adjustment2, 0, 0);
gtk_box_pack_start(GTK_BOX(box), thing, FALSE, TRUE, 0);
gtk_widget_show(thing);
gtk_signal_connect(GTK_OBJECT(thing), "changed",
GTK_SIGNAL_FUNC(gui_subs_slider_update_2), s);
}
gSlider::gSlider(gContainer *par, bool scrollbar) : gControl(par)
{
g_typ = Type_gSlider;
_mark = false;
_step = 1;
_page_step = 10;
_value = 0;
_min = 0;
_max = 100;
_tracking = true;
border = gtk_alignment_new(0, 0, 1, 1);
if (scrollbar)
return;
widget = gtk_vscale_new(NULL);
gtk_scale_set_draw_value(GTK_SCALE(widget), false);
init();
realize(false);
onChange = NULL;
g_signal_connect(G_OBJECT(widget), "value-changed", G_CALLBACK(cb_change), (gpointer)this);
//g_signal_connect_after(G_OBJECT(border),"expose-event",G_CALLBACK(slider_Expose),(gpointer)this);
}
void gSlider::orientation(int w,int h)
{
GtkAdjustment *adj;
GType type;
type = (w < h) ? GTK_TYPE_VSCALE : GTK_TYPE_HSCALE;
if (type != G_OBJECT_TYPE(widget))
{
adj = gtk_range_get_adjustment(GTK_RANGE(widget));
g_object_ref(adj);
gtk_widget_destroy(widget);
if (type == GTK_TYPE_VSCALE)
widget = gtk_vscale_new(adj);
else
widget = gtk_hscale_new(adj);
gtk_container_add(GTK_CONTAINER(border), widget);
gtk_scale_set_draw_value(GTK_SCALE(widget), false);
gtk_widget_show(widget);
widgetSignals();
g_signal_connect(G_OBJECT(widget), "value-changed", G_CALLBACK(cb_change), (gpointer)this);
g_object_unref(adj);
init();
}
}
void pVerticalSlider::constructor() {
gtkWidget = gtk_vscale_new_with_range(0, 100, 1);
gtk_scale_set_draw_value(GTK_SCALE(gtkWidget), false);
g_signal_connect_swapped(G_OBJECT(gtkWidget), "value-changed", G_CALLBACK(VerticalSlider_change), (gpointer)&verticalSlider);
setLength(verticalSlider.state.length);
setPosition(verticalSlider.state.position);
}
void scale_set_default_values( GtkScale *scale )
{
gtk_range_set_update_policy (GTK_RANGE (scale),
GTK_UPDATE_CONTINUOUS);
gtk_scale_set_digits (scale, 1);
gtk_scale_set_value_pos (scale, GTK_POS_TOP);
gtk_scale_set_draw_value (scale, TRUE);
}
/*
* @brief creates all GTK+ widgets that compose the player & sets up callbacks
* */
static void create_ui(CustomData *data) {
GtkWidget *main_window; /* uppermost container window */
GtkWidget *video_window; /* video is shown here */
GtkWidget *main_box; /* holds hbox & controls */
GtkWidget *main_hbox; /* hold video window & streaminfo widget */
GtkWidget *controls; /* hold buttons & slider */
GtkWidget *play_button, *pause_button, *stop_button;
GtkCellRenderer *renderer;
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(main_window), "delete-event", G_CALLBACK(delete_event_cb), data);
video_window = gtk_drawing_area_new();
gtk_widget_set_double_buffered(video_window, FALSE);
g_signal_connect(G_OBJECT(video_window), "realize", G_CALLBACK(realise_cb), data);
g_signal_connect (video_window, "expose_event", G_CALLBACK (expose_cb), data);
play_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PLAY);
g_signal_connect (G_OBJECT (play_button), "clicked", G_CALLBACK (play_cb), data);
pause_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PAUSE);
g_signal_connect (G_OBJECT (pause_button), "clicked", G_CALLBACK (pause_cb), data);
stop_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_STOP);
g_signal_connect (G_OBJECT (stop_button), "clicked", G_CALLBACK (stop_cb), data);
data->slider = gtk_hscale_new_with_range(0, 100, 1);
gtk_scale_set_draw_value(GTK_SCALE(data->slider), 0);
data->slider_update_signal_id = g_signal_connect (G_OBJECT (data->slider), "value-changed", G_CALLBACK (slider_cb), data);
data->streams_list = gtk_tree_view_new();
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_fixed_size(renderer, 15, -1);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(data->streams_list),
-1, "Stream Name", renderer, "text", COL_STREAM_NAME, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_fixed_size(renderer, 15, -1);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(data->streams_list),
-1, "Stream Details", renderer, "text", COL_STREAM_DETAILS, NULL);
g_signal_connect(data->streams_list, "row-activated", G_CALLBACK(stream_select_cb), data);
//gtk_text_view_set_editable (GTK_TEXT_VIEW (data->streams_list), FALSE);
controls = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (controls), play_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (controls), pause_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (controls), stop_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (controls), data->slider, TRUE, TRUE, 2);
main_box = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (main_box), video_window, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (main_box), data->streams_list, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (main_box), controls, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (main_window), main_box);
gtk_window_set_default_size (GTK_WINDOW (main_window), 640, 480);
gtk_widget_show_all (main_window);
}
void 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 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 gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_tool_lighttable_t *d = (dt_lib_tool_lighttable_t *)g_malloc0(sizeof(dt_lib_tool_lighttable_t));
self->data = (void *)d;
self->widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
d->layout = dt_conf_get_int("plugins/lighttable/layout");
d->previous_layout = d->layout == DT_LIGHTTABLE_LAYOUT_EXPOSE ? DT_LIGHTTABLE_LAYOUT_FILEMANAGER : DT_LIGHTTABLE_LAYOUT_EXPOSE;
d->current_zoom = dt_conf_get_int("plugins/lighttable/images_in_row");
/* create layout selection combobox */
d->layout_combo = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(d->layout_combo), _("zoomable light table"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(d->layout_combo), _("file manager"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(d->layout_combo), _("expose"));
gtk_combo_box_set_active(GTK_COMBO_BOX(d->layout_combo), d->layout);
g_signal_connect(G_OBJECT(d->layout_combo), "changed", G_CALLBACK(_lib_lighttable_layout_changed), (gpointer)self);
gtk_box_pack_start(GTK_BOX(self->widget), d->layout_combo, TRUE, TRUE, 0);
/* create horizontal zoom slider */
d->zoom = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 1, 21, 1);
gtk_widget_set_size_request(GTK_WIDGET(d->zoom), DT_PIXEL_APPLY_DPI(140), -1);
gtk_scale_set_draw_value(GTK_SCALE(d->zoom), FALSE);
gtk_range_set_increments(GTK_RANGE(d->zoom), 1, 1);
gtk_box_pack_start(GTK_BOX(self->widget), d->zoom, TRUE, TRUE, 0);
/* manual entry of the zoom level */
d->zoom_entry = gtk_entry_new();
gtk_entry_set_alignment(GTK_ENTRY(d->zoom_entry), 1.0);
gtk_entry_set_max_length(GTK_ENTRY(d->zoom_entry), 2);
gtk_entry_set_width_chars(GTK_ENTRY(d->zoom_entry), 3);
gtk_entry_set_max_width_chars(GTK_ENTRY(d->zoom_entry), 3);
dt_gui_key_accel_block_on_focus_connect(d->zoom_entry);
gtk_box_pack_start(GTK_BOX(self->widget), d->zoom_entry, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(d->zoom), "value-changed", G_CALLBACK(_lib_lighttable_zoom_slider_changed),
(gpointer)self);
g_signal_connect(d->zoom_entry, "key-press-event", G_CALLBACK(_lib_lighttable_zoom_entry_changed), self);
gtk_range_set_value(GTK_RANGE(d->zoom), d->current_zoom);
_lib_lighttable_zoom_slider_changed(GTK_RANGE(d->zoom), self); // the slider defaults to 1 and GTK doesn't
// fire a value-changed signal when setting
// it to 1 => empty text box
gtk_widget_set_no_show_all(d->zoom, TRUE);
gtk_widget_set_no_show_all(d->zoom_entry, TRUE);
_lib_lighttable_layout_changed(GTK_COMBO_BOX(d->layout_combo), self);
darktable.view_manager->proxy.lighttable.module = self;
darktable.view_manager->proxy.lighttable.set_zoom = _lib_lighttable_set_zoom;
darktable.view_manager->proxy.lighttable.get_zoom = _lib_lighttable_get_zoom;
darktable.view_manager->proxy.lighttable.get_layout = _lib_lighttable_get_layout;
darktable.view_manager->proxy.lighttable.set_layout = _lib_lighttable_set_layout;
}
void HorizontalSlider::create(Window &parent, unsigned x, unsigned y, unsigned width, unsigned height, unsigned length) {
object->position = 0;
length += (length == 0);
object->widget = gtk_hscale_new_with_range(0, length - 1, 1);
gtk_scale_set_draw_value(GTK_SCALE(object->widget), false);
gtk_widget_set_size_request(object->widget, width, height);
g_signal_connect_swapped(G_OBJECT(object->widget), "value-changed", G_CALLBACK(HorizontalSlider_change), (gpointer)this);
gtk_fixed_put(GTK_FIXED(parent.object->formContainer), object->widget, x, y);
gtk_widget_show(object->widget);
}
GtkWidget *create_audio_sliders()
{
GtkWidget *vbox, *scrollbar, *label, *pixmap_w;
GtkObject *adj;
GtkTooltips *tooltip;
int no_of_devs, i = -1, value;
tooltip = gtk_tooltips_new();
vbox = gtk_vbox_new (FALSE, 0);
mixer_id = mixer_init (getenv("LAV_MIXER_DEV"));
if (mixer_id > 0)
{
no_of_devs = mixer_num_of_devs (mixer_id);
for (i = 0; i < no_of_devs; i++)
{
if (strcmp(mixer_get_label(mixer_id, i), "Line ") == 0 && audio_recsrc == 'l')
{
break;
}
else if (strcmp(mixer_get_label(mixer_id, i), "Mic ") == 0 && audio_recsrc == 'm')
{
break;
}
else if (strcmp(mixer_get_label(mixer_id, i), "CD ") == 0 && audio_recsrc == 'c')
{
break;
}
}
}
value = 100 - mixer_get_vol_left(mixer_id, i);
label = gtk_label_new("\n");
gtk_box_pack_start(GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
adj = gtk_adjustment_new(value, 0, 100, 1, 10, 0);
gtk_signal_connect(adj, "value_changed", GTK_SIGNAL_FUNC(audio_slider_changed), NULL);
scrollbar = gtk_vscale_new(GTK_ADJUSTMENT (adj));
gtk_scale_set_draw_value(GTK_SCALE(scrollbar), 0);
gtk_box_pack_start(GTK_BOX (vbox), scrollbar, TRUE, TRUE, 0);
gtk_widget_show(scrollbar);
gtk_tooltips_set_tip(tooltip, scrollbar, "Volume", NULL);
pixmap_w = gtk_widget_from_xpm_data(slider_volume_xpm);
gtk_widget_show(pixmap_w);
gtk_box_pack_start(GTK_BOX(vbox), pixmap_w, FALSE, FALSE, 0);
label = gtk_label_new("\n");
gtk_box_pack_start(GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
return vbox;
}
/** create a control for float ports */
static GtkWidget *
create_float_control (plugin_desc_t * desc, unsigned long port_index)
{
LADSPA_Data lower;
LADSPA_Data upper;
GtkWidget *widget;
if (LADSPA_IS_HINT_SAMPLE_RATE (desc->port_range_hints[port_index].HintDescriptor))
{
lower =
desc->port_range_hints[port_index].LowerBound *
(LADSPA_Data) sample_rate;
upper =
desc->port_range_hints[port_index].UpperBound *
(LADSPA_Data) sample_rate;
}
else
{
lower = desc->port_range_hints[port_index].LowerBound;
upper = desc->port_range_hints[port_index].UpperBound;
}
if (!LADSPA_IS_HINT_BOUNDED_BELOW
(desc->port_range_hints[port_index].HintDescriptor))
{
lower = (LADSPA_Data) - 100.0;
}
if (!LADSPA_IS_HINT_BOUNDED_ABOVE
(desc->port_range_hints[port_index].HintDescriptor))
{
upper = (LADSPA_Data) 100.0;
}
if (LADSPA_IS_HINT_LOGARITHMIC (desc->port_range_hints[port_index].HintDescriptor))
{
if (lower < FLT_EPSILON)
lower = FLT_EPSILON;
lower = log (lower);
upper = log (upper);
}
widget = gtk_hscale_new_with_range ((gdouble) lower, (gdouble) upper, (upper - lower) / 10.0);
gtk_scale_set_draw_value (GTK_SCALE (widget), FALSE);
gtk_scale_set_digits (GTK_SCALE (widget), 8);
gtk_range_set_increments (GTK_RANGE (widget), (upper - lower) / 1000.0,
(upper - lower) / 10.0);
g_assert (widget != NULL);
return widget;
}
GtkWidget *create_video_sliders()
{
GtkWidget *hbox, *vbox, *pixmap, *scrollbar;
GtkTooltips *tooltip;
int i=0;
char *titles[4] = {
"Hue",
"Contrast",
"Brightness",
"Colour Saturation"
};
char *names[4] = {
"hue",
"contrast",
"brightness",
"colour"
};
GtkAdjustment *adj[4] = {
GTK_TVPLUG(tv)->hue_adj,
GTK_TVPLUG(tv)->contrast_adj,
GTK_TVPLUG(tv)->brightness_adj,
GTK_TVPLUG(tv)->saturation_adj,
};
char **pixmaps[4] = {
slider_hue_xpm,
slider_contrast_xpm,
slider_brightness_xpm,
slider_sat_colour_xpm,
};
tooltip = gtk_tooltips_new();
hbox = gtk_hbox_new(TRUE, 20);
for (i=0;i<4;i++)
{
vbox = gtk_vbox_new (FALSE, 0);
gtk_object_ref(GTK_OBJECT(adj[i]));
gtk_signal_connect(GTK_OBJECT(adj[i]), "value_changed",
GTK_SIGNAL_FUNC(video_slider_changed), names[i]);
scrollbar = gtk_vscale_new(adj[i]);
gtk_scale_set_draw_value(GTK_SCALE(scrollbar), 0);
gtk_box_pack_start(GTK_BOX (vbox), scrollbar, TRUE, TRUE, 10);
gtk_widget_show(scrollbar);
gtk_widget_set_usize(scrollbar, -1, 150);
gtk_tooltips_set_tip(tooltip, scrollbar, titles[i], NULL);
pixmap = gtk_widget_from_xpm_data(pixmaps[i]);
gtk_widget_show(pixmap);
gtk_box_pack_start(GTK_BOX(vbox), pixmap, FALSE, FALSE, 10);
gtk_box_pack_start(GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show(vbox);
}
return hbox;
}
/**
* Updates the alignment of the volume text which is shown on the
* volume popup_window (left click) around the scroll bar.
*/
void update_vol_text() {
gboolean show = TRUE;
if (g_key_file_has_key(keyFile,"PNMixer","DisplayTextVolume",NULL))
show = g_key_file_get_boolean(keyFile,"PNMixer","DisplayTextVolume",NULL);
if (show) {
GtkPositionType pos = GTK_POS_RIGHT;
if (g_key_file_has_key(keyFile,"PNMixer","TextVolumePosition",NULL)) {
gint pi = g_key_file_get_integer(keyFile,"PNMixer","TextVolumePosition",NULL);
pos =
pi==0?GTK_POS_TOP:
pi==1?GTK_POS_BOTTOM:
pi==2?GTK_POS_LEFT:
GTK_POS_RIGHT;
}
gtk_scale_set_draw_value (GTK_SCALE (vol_scale), TRUE);
gtk_scale_set_value_pos (GTK_SCALE (vol_scale), pos);
}
else
gtk_scale_set_draw_value (GTK_SCALE (vol_scale), FALSE);
}
/**
* Updates the alignment of the volume text which is shown on the
* volume popup_window (left click) around the scroll bar.
*/
void
update_vol_text(void)
{
gboolean show;
show = prefs_get_boolean("DisplayTextVolume", TRUE);
if (show) {
gint pi;
GtkPositionType pos;
pi = prefs_get_integer("TextVolumePosition", 0);
pos = pi == 0 ? GTK_POS_TOP : pi == 1 ? GTK_POS_BOTTOM : pi ==
2 ? GTK_POS_LEFT : GTK_POS_RIGHT;
gtk_scale_set_draw_value(GTK_SCALE(vol_scale), TRUE);
gtk_scale_set_value_pos(GTK_SCALE(vol_scale), pos);
} else
gtk_scale_set_draw_value(GTK_SCALE(vol_scale), FALSE);
}
SHOES_CONTROL_REF shoes_native_slider(VALUE self, shoes_canvas *canvas, shoes_place *place, VALUE attr, char *msg) {
SHOES_CONTROL_REF ref = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 0., 1., 0.01);
if (!NIL_P(shoes_hash_get(attr, rb_intern("tooltip")))) {
gtk_widget_set_tooltip_text(GTK_WIDGET(ref), RSTRING_PTR(shoes_hash_get(attr, rb_intern("tooltip"))));
}
gtk_scale_set_draw_value(GTK_SCALE(ref), FALSE);
g_signal_connect(G_OBJECT(ref), "value-changed",
G_CALLBACK(shoes_widget_changed), (gpointer)self);
return ref;
}
GtkWidget * AddVScaler( GtkAdjustment * adj,GtkWidget * parent,int digit )
{
GtkWidget * VS;
VS=gtk_vscale_new( adj );
gtk_widget_set_name( VS,"VS" );
gtk_widget_show( VS );
if ( parent ) gtk_box_pack_start( GTK_BOX( parent ),VS,TRUE,TRUE,0 );
// gtk_scale_set_value_pos( GTK_SCALE( VS ),GTK_POS_RIGHT );
if ( digit == -1 ) gtk_scale_set_draw_value( GTK_SCALE( VS ),FALSE );
else gtk_scale_set_digits( GTK_SCALE( VS ),digit );
return VS;
}
/* This creates all the GTK+ widgets that compose our application, and registers the callbacks */
static void create_ui (CustomData *data) {
GtkWidget *main_window; /* The uppermost window, containing all other windows */
GtkWidget *video_window; /* The drawing area where the video will be shown */
GtkWidget *main_box; /* VBox to hold main_hbox and the controls */
GtkWidget *main_hbox; /* HBox to hold the video_window and the stream info text widget */
GtkWidget *controls; /* HBox to hold the buttons and the slider */
GtkWidget *play_button, *pause_button, *stop_button; /* Buttons */
main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (G_OBJECT (main_window), "delete-event", G_CALLBACK (delete_event_cb), data);
video_window = gtk_drawing_area_new ();
gtk_widget_set_double_buffered (video_window, FALSE);
g_signal_connect (video_window, "realize", G_CALLBACK (realize_cb), data);
g_signal_connect (video_window, "draw", G_CALLBACK (draw_cb), data);
play_button = gtk_button_new_with_label("play");
g_signal_connect (G_OBJECT (play_button), "clicked", G_CALLBACK (play_cb), data);
pause_button = gtk_button_new_with_label("pause");
g_signal_connect (G_OBJECT (pause_button), "clicked", G_CALLBACK (pause_cb), data);
stop_button = gtk_button_new_with_label("stop");
g_signal_connect (G_OBJECT (stop_button), "clicked", G_CALLBACK (stop_cb), data);
data->slider = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,0, 100, 1);
gtk_scale_set_draw_value (GTK_SCALE (data->slider), 0);
data->slider_update_signal_id = g_signal_connect (G_OBJECT (data->slider), "value-changed", G_CALLBACK (slider_cb), data);
data->streams_list = gtk_text_view_new ();
gtk_text_view_set_editable (GTK_TEXT_VIEW (data->streams_list), FALSE);
controls = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (controls), play_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (controls), pause_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (controls), stop_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (controls), data->slider, TRUE, TRUE, 2);
main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (main_hbox), video_window, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (main_hbox), data->streams_list, FALSE, FALSE, 2);
main_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (main_box), main_hbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (main_box), controls, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (main_window), main_box);
gtk_window_set_default_size (GTK_WINDOW (main_window), 640, 480);
gtk_widget_realize(video_window);
gtk_widget_show_all (main_window);
}
GtkWidget *slider_int_new(char *label_str, int *data, int lower, int upper,
int vert)
{
Slider *slider;
GtkWidget *label;
slider = gtk_type_new(slider_get_type());
gtk_container_border_width(GTK_CONTAINER(slider), 1);
slider->type = SLIDER_TYPE_INT;
slider->data.iptr = data;
snprintf(slider->value_str, sizeof(slider->value_str), "%d",
*data);
slider->value_label = gtk_label_new(slider->value_str);
gtk_box_pack_start(GTK_BOX(slider), slider->value_label, FALSE,
TRUE, 0);
gtk_widget_show(slider->value_label);
slider->adj = gtk_adjustment_new((gfloat) (lower + upper - *data),
(gfloat) lower, (gfloat) upper,
1.0, 1.0, 0.0);
if (vert) {
slider->scale =
GTK_SCALE(gtk_vscale_new(GTK_ADJUSTMENT(slider->adj)));
/* gtk_widget_set_usize(GTK_WIDGET(slider->scale), 16, 120); */
} else {
slider->scale =
GTK_SCALE(gtk_hscale_new(GTK_ADJUSTMENT(slider->adj)));
/* gtk_widget_set_usize(GTK_WIDGET(slider->scale), 120, 16); */
}
gtk_box_pack_start(GTK_BOX(slider), GTK_WIDGET(slider->scale),
TRUE, TRUE, 0);
gtk_range_set_update_policy(GTK_RANGE(slider->scale),
GTK_UPDATE_CONTINUOUS);
/* draw number above scale */
gtk_scale_set_draw_value(GTK_SCALE(slider->scale), FALSE);
g_signal_connect(G_OBJECT(slider->adj), "value_changed",
G_CALLBACK(slider_cb), slider);
gtk_widget_show(GTK_WIDGET(slider->scale));
label = gtk_label_new(label_str);
gtk_box_pack_start(GTK_BOX(slider), label, FALSE, FALSE, 0);
gtk_widget_show(label);
return GTK_WIDGET(slider);
}
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;
}
