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;
}
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();
}
}
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkVScale_gtk_1vscale_1new
(
JNIEnv* env,
jclass cls,
jlong _adjustment
)
{
GtkWidget* result;
jlong _result;
GtkAdjustment* adjustment;
// convert parameter adjustment
adjustment = (GtkAdjustment*) _adjustment;
// call function
result = gtk_vscale_new(adjustment);
// cleanup parameter adjustment
// translate return value to JNI type
_result = (jlong) result;
// cleanup return value
if (result != NULL) {
bindings_java_memory_cleanup((GObject*)result, TRUE);
}
// and finally
return _result;
}
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);
}
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);
}
GtkWidget* RenderThemeGtk::gtkVScale() const
{
if (m_gtkVScale)
return m_gtkVScale;
m_gtkVScale = gtk_vscale_new(0);
setupWidgetAndAddToContainer(m_gtkVScale, gtkContainer());
return m_gtkVScale;
}
GtkWidget *
gtk_scale_new (GtkOrientation orientation,
GtkAdjustment *adjustment)
{
if (orientation == GTK_ORIENTATION_HORIZONTAL)
return gtk_hscale_new (adjustment);
else
return gtk_vscale_new (adjustment);
}
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;
}
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;
}
/*#
@class GtkVScale
@brief A vertical slider widget for selecting a value from a range
@param adjustment the GtkAdjustment which sets the range of the scale.
The GtkVScale widget is used to allow the user to select a value using a
vertical slider.
The position to show the current value, and the number of decimal places
shown can be set using the parent GtkScale class's functions.
*/
FALCON_FUNC VScale::init( VMARG )
{
Item* i_adj = vm->param( 0 );
#ifndef NO_PARAMETER_CHECK
if ( !i_adj || !i_adj->isObject() || !IS_DERIVED( i_adj, GtkAdjustment ) )
throw_inv_params( "GtkAdjustment" );
#endif
GtkAdjustment* adj = (GtkAdjustment*) COREGOBJECT( i_adj )->getObject();
MYSELF;
self->setObject( (GObject*) gtk_vscale_new( adj ) );
}
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;
}
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 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;
}
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 VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE arg1, arg2, arg3;
GtkAdjustment *adj = NULL;
GtkWidget *widget;
rb_scan_args(argc, argv, "03", &arg1, &arg2, &arg3);
if (NIL_P(arg1) || RVAL2GTYPE(arg1) == GTK_TYPE_ADJUSTMENT){
if (!NIL_P(arg1)) adj = GTK_ADJUSTMENT(RVAL2GOBJ(arg1));
widget = gtk_vscale_new(adj);
} else {
widget = gtk_vscale_new_with_range(NUM2DBL(arg1),
NUM2DBL(arg2), NUM2DBL(arg3));
}
RBGTK_INITIALIZE(self, widget);
return Qnil;
}
static void init_vert_info_window(void)
{
scope_vert_t *vert;
GtkWidget *hbox, *vbox;
GtkWidget *button;
vert = &(ctrl_usr->vert);
/* box for the two sliders */
hbox =
gtk_hbox_new_in_box(TRUE, 0, 0, ctrl_usr->vert_info_win, TRUE, TRUE,
0);
/* box for the scale slider */
vbox = gtk_vbox_new_in_box(FALSE, 0, 0, hbox, TRUE, TRUE, 0);
gtk_label_new_in_box(_("Gain"), vbox, FALSE, FALSE, 0);
vert->scale_adj = gtk_adjustment_new(0, -5, 5, 1, 1, 0);
vert->scale_slider = gtk_vscale_new(GTK_ADJUSTMENT(vert->scale_adj));
gtk_scale_set_digits(GTK_SCALE(vert->scale_slider), 0);
gtk_scale_set_draw_value(GTK_SCALE(vert->scale_slider), FALSE);
gtk_box_pack_start(GTK_BOX(vbox), vert->scale_slider, TRUE, TRUE, 0);
/* connect the slider to a function that re-calcs vertical scale */
gtk_signal_connect(GTK_OBJECT(vert->scale_adj), "value_changed",
GTK_SIGNAL_FUNC(scale_changed), NULL);
gtk_widget_show(vert->scale_slider);
/* box for the position slider */
vbox = gtk_vbox_new_in_box(FALSE, 0, 0, hbox, TRUE, TRUE, 0);
gtk_label_new_in_box(_("Pos"), vbox, FALSE, FALSE, 0);
vert->pos_adj =
gtk_adjustment_new(VERT_POS_RESOLUTION / 2, 0, VERT_POS_RESOLUTION, 1,
1, 0);
vert->pos_slider = gtk_vscale_new(GTK_ADJUSTMENT(vert->pos_adj));
gtk_scale_set_digits(GTK_SCALE(vert->pos_slider), 0);
gtk_scale_set_draw_value(GTK_SCALE(vert->pos_slider), FALSE);
gtk_box_pack_start(GTK_BOX(vbox), vert->pos_slider, TRUE, TRUE, 0);
/* connect the slider to a function that re-calcs vertical pos */
gtk_signal_connect(GTK_OBJECT(vert->pos_adj), "value_changed",
GTK_SIGNAL_FUNC(pos_changed), NULL);
gtk_widget_show(vert->pos_slider);
/* Scale display */
gtk_hseparator_new_in_box(ctrl_usr->vert_info_win, 3);
gtk_label_new_in_box(_("Scale"), ctrl_usr->vert_info_win, FALSE, FALSE, 0);
vert->scale_label =
gtk_label_new_in_box(" ---- ", ctrl_usr->vert_info_win, FALSE, FALSE,
0);
/* Offset control */
vert->offset_button = gtk_button_new_with_label("Offset\n----");
vert->offset_label = (GTK_BIN(vert->offset_button))->child;
gtk_box_pack_start(GTK_BOX(ctrl_usr->vert_info_win),
vert->offset_button, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(vert->offset_button), "clicked",
GTK_SIGNAL_FUNC(offset_button), NULL);
gtk_widget_show(vert->offset_button);
/* a button to turn off the channel */
button = gtk_button_new_with_label(_("Chan Off"));
gtk_box_pack_start(GTK_BOX(ctrl_usr->vert_info_win), button, FALSE, FALSE,
0);
/* turn off the channel if button is clicked */
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(channel_off_button), NULL);
gtk_widget_show(button);
}
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 GtkWidget *get_video_sliders_widget()
{
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_signal_connect(GTK_OBJECT(adj[i]), "value_changed",
GTK_SIGNAL_FUNC(video_slider_changed), names[i]);
gtk_object_ref(GTK_OBJECT(adj[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);
}
#ifdef OSS
/* Audio volume slider */
if (mixer_id > 0)
{
vbox = gtk_vbox_new (FALSE, 0);
adj_audio = GTK_ADJUSTMENT(gtk_adjustment_new(100-volume,0,100,1,10,0));
gtk_signal_connect(GTK_OBJECT(adj_audio), "value_changed",
GTK_SIGNAL_FUNC(audio_slider_changed), NULL);
scrollbar = gtk_vscale_new(adj_audio);
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, "Audio Volume", NULL);
pixmap = gtk_widget_from_xpm_data(slider_volume_xpm);
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);
}
#endif
return hbox;
}
plugin_strip *
create_plugin_strip(GtkWidget *parent_window, d3h_instance_t *instance)
{
plugin_strip *ps = (plugin_strip *)calloc(1, sizeof(plugin_strip));
GtkWidget *vbox1;
char buf[12];
GtkWidget *hbox1;
GtkWidget *striplabel1;
GtkWidget *striplabel2;
GtkWidget *hbox2;
#if 0
GtkWidget *config_button;
#endif
#if 0
GtkWidget *hscale1;
GtkWidget *vscale1;
#endif
ps->instance = instance;
ps->container = gtk_frame_new (NULL);
gtk_widget_ref (ps->container);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "frame1", ps->container,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (ps->container);
gtk_container_set_border_width (GTK_CONTAINER (ps->container), 2);
gtk_frame_set_shadow_type (GTK_FRAME (ps->container), GTK_SHADOW_OUT);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (ps->container), vbox1);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox1);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "hbox1", hbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
ps->midi_status = blinky_new(0);
gtk_widget_ref (ps->midi_status);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "midi_status", ps->midi_status,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (ps->midi_status);
gtk_box_pack_start (GTK_BOX (hbox1), ps->midi_status, FALSE, FALSE, 1);
ps->previous_midi_state = 0;
snprintf(buf, 12, "Inst %d", instance->id);
striplabel1 = gtk_label_new (buf);
gtk_widget_ref (striplabel1);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "striplabel1", striplabel1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (striplabel1);
gtk_box_pack_start (GTK_BOX (hbox1), striplabel1, FALSE, FALSE, 1);
/* gtk_misc_set_alignment (GTK_MISC (striplabel1), 0, 0.5); -FIX- */
/* gtk_misc_set_padding (GTK_MISC (striplabel1), 3, 0); -FIX- */
snprintf(buf, 12, "%s", instance->plugin->label);
striplabel2 = gtk_label_new (buf);
gtk_widget_ref (striplabel2);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "striplabel2", striplabel2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (striplabel2);
gtk_box_pack_start (GTK_BOX (vbox1), striplabel2, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (striplabel2), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (striplabel2), 3, 0);
hbox2 = gtk_hbox_new (TRUE, 0);
gtk_widget_ref (hbox2);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "hbox2", hbox2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox1), hbox2, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 3);
#if 0
config_button = gtk_button_new_with_label ("Cfg");
gtk_widget_ref (config_button);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "config_button", config_button,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (config_button);
gtk_box_pack_start (GTK_BOX (hbox2), config_button, FALSE, FALSE, 0);
#endif
ps->ui_button = gtk_toggle_button_new_with_label ("UI");
gtk_widget_ref (ps->ui_button);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "ui_button", ps->ui_button,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (ps->ui_button);
gtk_box_pack_end (GTK_BOX (hbox2), ps->ui_button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (ps->ui_button), "toggled",
GTK_SIGNAL_FUNC (on_strip_ui_button_toggled),
(gpointer)ps);
gtk_signal_connect (GTK_OBJECT (ps->ui_button), "button_press_event",
GTK_SIGNAL_FUNC (on_strip_ui_button_event),
(gpointer)ps);
#if 0
ps->pan_adjustment = gtk_adjustment_new (48, 0, 100, 1, 10, 0);
hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (ps->pan_adjustment));
gtk_widget_ref (hscale1);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "hscale1", hscale1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hscale1);
gtk_box_pack_start (GTK_BOX (vbox1), hscale1, FALSE, FALSE, 0);
gtk_scale_set_digits (GTK_SCALE (hscale1), 0);
ps->level_adjustment = gtk_adjustment_new (-120, -120, 10, -1, -6, -1);
vscale1 = gtk_vscale_new (GTK_ADJUSTMENT (ps->level_adjustment));
gtk_widget_ref (vscale1);
gtk_object_set_data_full (GTK_OBJECT (parent_window), "vscale1", vscale1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vscale1);
gtk_box_pack_start (GTK_BOX (vbox1), vscale1, TRUE, TRUE, 0);
#endif
return ps;
}
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
Launch_Gtk_Process(int pipe_number)
{
int argc = 0;
gchar **argv = NULL;
GtkWidget *button, *mbar, *swin;
GtkWidget *table, *align, *handlebox;
GtkWidget *vbox, *hbox, *vbox2, *scrolled_win;
GtkObject *adj;
/* enable locale */
gtk_set_locale ();
gtk_init (&argc, &argv);
ttip = create_yellow_tooltips();
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name(window, "TiMidity");
gtk_window_set_title(GTK_WINDOW(window), "TiMidity - MIDI Player");
gtk_window_set_wmclass(GTK_WINDOW(window), "timidity", "TiMidity");
gtk_signal_connect(GTK_OBJECT(window), "delete_event",
GTK_SIGNAL_FUNC (delete_event), NULL);
gtk_signal_connect(GTK_OBJECT(window), "destroy",
GTK_SIGNAL_FUNC (destroy), NULL);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
mbar = create_menubar();
gtk_box_pack_start(GTK_BOX(vbox), mbar, FALSE, FALSE, 0);
scrolled_win = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(vbox), scrolled_win, TRUE, TRUE ,0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_widget_show(scrolled_win);
#ifdef HAVE_GTK_2
text = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD);
#else
text = gtk_text_new(NULL, NULL);
#endif
gtk_widget_show(text);
gtk_container_add(GTK_CONTAINER(scrolled_win), text);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 4);
gtk_widget_show(hbox);
adj = gtk_adjustment_new(0., 0., 100., 1., 20., 0.);
locator = gtk_hscale_new(GTK_ADJUSTMENT(adj));
gtk_scale_set_draw_value(GTK_SCALE(locator), TRUE);
gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
GTK_SIGNAL_FUNC(generic_scale_cb),
(gpointer)GTK_CHANGE_LOCATOR);
gtk_signal_connect(GTK_OBJECT(locator), "button_press_event",
GTK_SIGNAL_FUNC(locate_update_cb),
NULL);
gtk_signal_connect(GTK_OBJECT(locator), "button_release_event",
GTK_SIGNAL_FUNC(locate_update_cb),
NULL);
gtk_range_set_update_policy(GTK_RANGE(locator),
GTK_UPDATE_DISCONTINUOUS);
gtk_scale_set_digits(GTK_SCALE(locator), 0);
gtk_widget_show(locator);
gtk_box_pack_start(GTK_BOX(hbox), locator, TRUE, TRUE, 4);
align = gtk_alignment_new(0., 1., 1., 0.);
gtk_widget_show(align);
cnt_lbl = gtk_label_new("00:00");
gtk_widget_show(cnt_lbl);
gtk_container_add(GTK_CONTAINER(align), cnt_lbl);
gtk_box_pack_start(GTK_BOX(hbox), align, FALSE, TRUE, 0);
align = gtk_alignment_new(0., 1., 1., 0.);
gtk_widget_show(align);
tot_lbl = gtk_label_new("/00:00");
gtk_widget_show(tot_lbl);
gtk_container_add(GTK_CONTAINER(align), tot_lbl);
gtk_box_pack_start(GTK_BOX(hbox), align, FALSE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 4);
swin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
clist = gtk_clist_new(1);
gtk_container_add(GTK_CONTAINER(swin), clist);
gtk_widget_show(swin);
gtk_widget_show(clist);
gtk_widget_set_usize(clist, 200, 10);
gtk_clist_set_reorderable(GTK_CLIST(clist), TRUE);
gtk_clist_set_button_actions(GTK_CLIST(clist), 0, GTK_BUTTON_SELECTS);
gtk_clist_set_button_actions(GTK_CLIST(clist), 1, GTK_BUTTON_DRAGS);
gtk_clist_set_button_actions(GTK_CLIST(clist), 2, GTK_BUTTON_SELECTS);
gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_SINGLE);
gtk_clist_set_column_auto_resize(GTK_CLIST(clist), 1, TRUE);
gtk_signal_connect(GTK_OBJECT(clist), "select_row",
GTK_SIGNAL_FUNC(file_list_cb), NULL);
gtk_box_pack_start(GTK_BOX(hbox), swin, TRUE, TRUE, 0);
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox2, FALSE, FALSE, 0);
gtk_widget_show(vbox2);
/* This is so the pixmap creation works properly. */
gtk_widget_realize(window);
set_icon_pixmap(window, timidity_xpm);
gtk_box_pack_start(GTK_BOX(vbox2),
create_pixmap_label(window, loud_xpm),
FALSE, FALSE, 0);
adj = gtk_adjustment_new(30., 0., (gfloat)MAX_AMPLIFICATION, 1., 20., 0.);
vol_scale = gtk_vscale_new(GTK_ADJUSTMENT(adj));
gtk_scale_set_draw_value(GTK_SCALE(vol_scale), FALSE);
gtk_signal_connect (GTK_OBJECT(adj), "value_changed",
GTK_SIGNAL_FUNC(generic_scale_cb),
(gpointer)GTK_CHANGE_VOLUME);
gtk_range_set_update_policy(GTK_RANGE(vol_scale),
GTK_UPDATE_DELAYED);
gtk_widget_show(vol_scale);
gtk_tooltips_set_tip(ttip, vol_scale, "Volume control", NULL);
gtk_box_pack_start(GTK_BOX(vbox2), vol_scale, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox2),
create_pixmap_label(window, quiet_xpm),
FALSE, FALSE, 0);
handlebox = gtk_handle_box_new();
gtk_box_pack_start(GTK_BOX(hbox), handlebox, FALSE, FALSE, 0);
table = gtk_table_new(7, 2, TRUE);
gtk_container_add(GTK_CONTAINER(handlebox), table);
button = create_button_with_pixmap(window, playpaus_xpm, GTK_PAUSE,
"Play/Pause");
gtk_table_attach_defaults(GTK_TABLE(table), button,
0, 2, 0, 1);
button = create_button_with_pixmap(window, prevtrk_xpm, GTK_PREV,
"Previous file");
gtk_table_attach_defaults(GTK_TABLE(table), button,
0, 1, 1, 2);
button = create_button_with_pixmap(window, nexttrk_xpm, GTK_NEXT,
"Next file");
gtk_table_attach_defaults(GTK_TABLE(table), button,
1, 2, 1, 2);
button = create_button_with_pixmap(window, rew_xpm, GTK_RWD,
"Rewind");
gtk_table_attach_defaults(GTK_TABLE(table), button,
0, 1, 2, 3);
button = create_button_with_pixmap(window, ff_xpm, GTK_FWD,
"Fast forward");
gtk_table_attach_defaults(GTK_TABLE(table), button,
1, 2, 2, 3);
button = create_button_with_pixmap(window, keydown_xpm, GTK_KEYDOWN,
"Lower pitch");
gtk_table_attach_defaults(GTK_TABLE(table), button,
0, 1, 3, 4);
button = create_button_with_pixmap(window, keyup_xpm, GTK_KEYUP,
"Raise pitch");
gtk_table_attach_defaults(GTK_TABLE(table), button,
1, 2, 3, 4);
button = create_button_with_pixmap(window, slow_xpm, GTK_SLOWER,
"Decrease tempo");
gtk_table_attach_defaults(GTK_TABLE(table), button,
0, 1, 4, 5);
button = create_button_with_pixmap(window, fast_xpm, GTK_FASTER,
"Increase tempo");
gtk_table_attach_defaults(GTK_TABLE(table), button,
1, 2, 4, 5);
button = create_button_with_pixmap(window, restart_xpm, GTK_RESTART,
"Restart");
gtk_table_attach_defaults(GTK_TABLE(table), button,
0, 1, 5, 6);
button = create_button_with_pixmap(window, open_xpm, 0,
"Open");
#ifdef HAVE_GTK_2
gtk_signal_disconnect_by_func(GTK_OBJECT(button), G_CALLBACK(generic_cb), 0);
#else
gtk_signal_disconnect_by_func(GTK_OBJECT(button), generic_cb, 0);
#endif
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(open_file_cb), 0);
gtk_table_attach_defaults(GTK_TABLE(table), button,
1, 2, 5, 6);
button = create_button_with_pixmap(window, quit_xpm, GTK_QUIT,
"Quit");
gtk_table_attach_defaults(GTK_TABLE(table), button,
0, 2, 6, 7);
gtk_widget_show(hbox);
gtk_widget_show(vbox);
gtk_widget_show(table);
gtk_widget_show(handlebox);
gtk_widget_show(window);
gdk_input_add(pipe_number, GDK_INPUT_READ, handle_input, NULL);
gtk_main();
}
void
create_orientmap_dialog (GtkWidget *parent)
{
GtkWidget *tmpw, *tmpw2;
GtkWidget *table1, *table2;
GtkWidget *frame;
GtkWidget *ebox, *hbox, *vbox;
init_vectors ();
if (orient_map_window)
{
update_vector_prev ();
update_orient_map_preview_prev ();
gtk_widget_show (orient_map_window);
return;
}
orient_map_window =
gimp_dialog_new (_("Orientation Map Editor"), PLUG_IN_BINARY,
gtk_widget_get_toplevel (parent), 0,
gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_APPLY, GTK_RESPONSE_APPLY,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (orient_map_window),
GTK_RESPONSE_OK,
GTK_RESPONSE_APPLY,
GTK_RESPONSE_CANCEL,
-1);
g_signal_connect (orient_map_window, "response",
G_CALLBACK (orient_map_response),
orient_map_window);
g_signal_connect (orient_map_window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&orient_map_window);
table1 = gtk_table_new (2, 5, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table1), 6);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (orient_map_window))),
table1, TRUE, TRUE, 0);
gtk_widget_show (table1);
frame = gtk_frame_new (_("Vectors"));
gtk_container_set_border_width (GTK_CONTAINER (frame), 2);
gtk_table_attach (GTK_TABLE (table1), frame, 0, 1, 0, 1,
GTK_EXPAND, GTK_EXPAND, 0, 0);
gtk_widget_show (frame);
hbox = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_widget_show (hbox);
ebox = gtk_event_box_new ();
gimp_help_set_help_data (ebox,
_("The vector-field. "
"Left-click to move selected vector, "
"Right-click to point it towards mouse, "
"Middle-click to add a new vector."), NULL);
gtk_box_pack_start (GTK_BOX (hbox), ebox, FALSE, FALSE, 0);
tmpw = vector_preview = gimp_preview_area_new ();
gtk_widget_set_size_request (tmpw, OMWIDTH, OMHEIGHT);
gtk_container_add (GTK_CONTAINER (ebox), tmpw);
gtk_widget_show (tmpw);
gtk_widget_add_events (ebox, GDK_BUTTON_PRESS_MASK);
g_signal_connect (ebox, "button-press-event",
G_CALLBACK (map_click_callback), NULL);
gtk_widget_show (ebox);
vector_preview_brightness_adjust =
gtk_adjustment_new (50.0, 0.0, 100.0, 1.0, 1.0, 1.0);
tmpw = gtk_vscale_new (GTK_ADJUSTMENT (vector_preview_brightness_adjust));
gtk_scale_set_draw_value (GTK_SCALE (tmpw), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), tmpw, FALSE, FALSE,0);
gtk_widget_show (tmpw);
g_signal_connect (vector_preview_brightness_adjust, "value-changed",
G_CALLBACK (update_vector_prev), NULL);
gimp_help_set_help_data (tmpw, _("Adjust the preview's brightness"), NULL);
tmpw2 = tmpw = gtk_frame_new (_("Preview"));
gtk_container_set_border_width (GTK_CONTAINER (tmpw), 2);
gtk_table_attach (GTK_TABLE (table1), tmpw, 1,2, 0,1,
GTK_EXPAND, GTK_EXPAND, 0, 0);
gtk_widget_show (tmpw);
tmpw = orient_map_preview_prev = gimp_preview_area_new ();
gtk_widget_set_size_request (tmpw, OMWIDTH, OMHEIGHT);;
gtk_container_add (GTK_CONTAINER (tmpw2), tmpw);
gtk_widget_show (tmpw);
hbox = tmpw = gtk_hbox_new (TRUE,0);
gtk_container_set_border_width (GTK_CONTAINER (tmpw), 2);
gtk_table_attach_defaults (GTK_TABLE (table1), tmpw, 0,1, 1,2);
gtk_widget_show (tmpw);
prev_button = tmpw = gtk_button_new_with_mnemonic ("_<<");
gtk_box_pack_start (GTK_BOX (hbox), tmpw, FALSE, TRUE, 0);
gtk_widget_show (tmpw);
g_signal_connect (tmpw, "clicked", G_CALLBACK (prev_click_callback), NULL);
gimp_help_set_help_data (tmpw, _("Select previous vector"), NULL);
next_button = tmpw = gtk_button_new_with_mnemonic ("_>>");
gtk_box_pack_start (GTK_BOX (hbox),tmpw,FALSE,TRUE,0);
gtk_widget_show (tmpw);
g_signal_connect (tmpw, "clicked", G_CALLBACK (next_click_callback), NULL);
gimp_help_set_help_data (tmpw, _("Select next vector"), NULL);
add_button = tmpw = gtk_button_new_with_mnemonic ( _("A_dd"));
gtk_box_pack_start (GTK_BOX (hbox), tmpw, FALSE, TRUE, 0);
gtk_widget_show (tmpw);
g_signal_connect (tmpw, "clicked", G_CALLBACK (add_click_callback), NULL);
gimp_help_set_help_data (tmpw, _("Add new vector"), NULL);
kill_button = tmpw = gtk_button_new_with_mnemonic ( _("_Kill"));
gtk_box_pack_start (GTK_BOX (hbox), tmpw, FALSE, TRUE, 0);
gtk_widget_show (tmpw);
g_signal_connect (tmpw, "clicked", G_CALLBACK (delete_click_callback), NULL);
gimp_help_set_help_data (tmpw, _("Delete selected vector"), NULL);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_set_spacing (GTK_BOX (hbox), 12);
gtk_table_attach_defaults (GTK_TABLE (table1), hbox, 0, 2, 2, 3);
gtk_widget_show (hbox);
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
frame = gimp_int_radio_group_new (TRUE, _("Type"),
G_CALLBACK (vector_type_click_callback),
&vector_type, 0,
_("_Normal"), 0, &vector_types[0],
_("Vorte_x"), 1, &vector_types[1],
_("Vortex_2"), 2, &vector_types[2],
_("Vortex_3"), 3, &vector_types[3],
NULL);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
orient_voronoi = tmpw = gtk_check_button_new_with_mnemonic ( _("_Voronoi"));
gtk_box_pack_start (GTK_BOX (vbox), tmpw, TRUE, TRUE, 0);
gtk_widget_show (tmpw);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tmpw),
pcvals.orient_voronoi);
g_signal_connect (tmpw, "clicked",
G_CALLBACK (angle_offset_adjust_move_callback), NULL);
gimp_help_set_help_data (tmpw,
_("Voronoi-mode makes only the vector closest to the given point have any influence"),
NULL);
table2 = gtk_table_new (4, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table2), 4);
gtk_box_pack_start (GTK_BOX (hbox), table2, TRUE, TRUE, 0);
gtk_widget_show (table2);
angle_adjust =
gimp_scale_entry_new (GTK_TABLE (table2), 0, 0,
_("A_ngle:"),
150, 6, 0.0,
0.0, 360.0, 1.0, 10.0, 1,
TRUE, 0, 0,
_("Change the angle of the selected vector"),
NULL);
g_signal_connect (angle_adjust, "value-changed",
G_CALLBACK (angle_adjust_move_callback), NULL);
angle_offset_adjust =
gimp_scale_entry_new (GTK_TABLE (table2), 0, 1,
_("Ang_le offset:"),
150, 6, 0.0,
0.0, 360.0, 1.0, 10.0, 1,
TRUE, 0, 0,
_("Offset all vectors with a given angle"),
NULL);
g_signal_connect (angle_offset_adjust, "value-changed",
G_CALLBACK (angle_offset_adjust_move_callback), NULL);
strength_adjust =
gimp_scale_entry_new (GTK_TABLE (table2), 0, 2,
_("_Strength:"),
150, 6, 1.0,
0.1, 5.0, 0.1, 1.0, 1,
TRUE, 0, 0,
_("Change the strength of the selected vector"),
NULL);
g_signal_connect (strength_adjust, "value-changed",
G_CALLBACK (strength_adjust_move_callback), NULL);
orient_map_str_exp_adjust =
gimp_scale_entry_new (GTK_TABLE (table2), 0, 3,
_("S_trength exp.:"),
150, 6, 1.0,
0.1, 10.9, 0.1, 1.0, 1,
TRUE, 0, 0,
_("Change the exponent of the strength"),
NULL);
g_signal_connect (orient_map_str_exp_adjust, "value-changed",
G_CALLBACK (strength_exponent_adjust_move_callback), NULL);
gtk_widget_show (orient_map_window);
update_vector_prev ();
update_orient_map_preview_prev ();
}
GtkWidget*
create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *label1;
GtkObject *spinbutton1_adj;
GtkWidget *spinbutton1;
GtkWidget *hscale1;
GtkWidget *hbox2;
GtkWidget *drawingarea1;
GtkWidget *vscale1;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Subtitle Size and Position"));
gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
label1 = gtk_label_new (QT_TR_NOOP("Font Size:"));
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (hbox1), label1, FALSE, FALSE, 0);
spinbutton1_adj = gtk_adjustment_new (1, 6, 99, 1, 10, 10);
spinbutton1 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton1_adj), 1, 2);
gtk_widget_show (spinbutton1);
gtk_box_pack_start (GTK_BOX (hbox1), spinbutton1, FALSE, FALSE, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton1), TRUE);
hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 99, 1, 1, 1)));
gtk_widget_show (hscale1);
gtk_box_pack_start (GTK_BOX (vbox1), hscale1, FALSE, FALSE, 0);
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox1), hbox2, TRUE, TRUE, 0);
drawingarea1 = gtk_drawing_area_new ();
gtk_widget_show (drawingarea1);
gtk_box_pack_start (GTK_BOX (hbox2), drawingarea1, TRUE, TRUE, 0);
vscale1 = gtk_vscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 100, 1, 1, 1, 1)));
gtk_widget_show (vscale1);
gtk_box_pack_start (GTK_BOX (hbox2), vscale1, FALSE, FALSE, 0);
gtk_scale_set_digits (GTK_SCALE (vscale1), 0);
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, spinbutton1, "spinbutton1");
GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1");
GLADE_HOOKUP_OBJECT (dialog1, hbox2, "hbox2");
GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1");
GLADE_HOOKUP_OBJECT (dialog1, vscale1, "vscale1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
GtkWidget*
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;
}
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;
}
/*
Almost straigh out of glade2
*/
GtkWidget*
create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *table1;
GtkWidget *label1;
GtkWidget *label2;
GtkWidget *label3;
GtkWidget *label4;
GtkWidget *hbox1;
GtkWidget *label_sub;
GtkWidget *button_sub;
GtkWidget *image1;
GtkWidget *hbox2;
GtkWidget *label_font;
GtkWidget *button_font;
GtkWidget *image2;
GtkWidget *optionmenu1;
GtkWidget *menu1;
GtkWidget *enc_ascii;
/*
GtkWidget *enc_8859;
GtkWidget *ebc_cyrillic;
GtkWidget *enc_german;
*/
GtkObject *spinbutton_fontsize_adj;
GtkWidget *spinbutton_fontsize;
GtkWidget *label5;
GtkWidget *button_color;
GtkWidget *hbox3;
GtkWidget *drawingarea1;
GtkWidget *vscale1;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *applybutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), _("Subtitle selector"));
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
table1 = gtk_table_new (5, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox1), table1, TRUE, TRUE, 0);
label1 = gtk_label_new (_("Subtitle file "));
gtk_widget_show (label1);
gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5);
label2 = gtk_label_new (_("Font (TTF)"));
gtk_widget_show (label2);
gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5);
label3 = gtk_label_new (_("Encoding "));
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
label4 = gtk_label_new (_("Font Size"));
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_table_attach (GTK_TABLE (table1), hbox1, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
label_sub = gtk_label_new (_("sub"));
gtk_widget_show (label_sub);
gtk_box_pack_start (GTK_BOX (hbox1), label_sub, TRUE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label_sub), GTK_JUSTIFY_LEFT);
button_sub = gtk_button_new ();
gtk_widget_show (button_sub);
gtk_box_pack_start (GTK_BOX (hbox1), button_sub, FALSE, FALSE, 0);
image1 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image1);
gtk_container_add (GTK_CONTAINER (button_sub), image1);
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox2);
gtk_table_attach (GTK_TABLE (table1), hbox2, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
label_font = gtk_label_new (_("font"));
gtk_widget_show (label_font);
gtk_box_pack_start (GTK_BOX (hbox2), label_font, TRUE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label_font), GTK_JUSTIFY_LEFT);
button_font = gtk_button_new ();
gtk_widget_show (button_font);
gtk_box_pack_start (GTK_BOX (hbox2), button_font, FALSE, FALSE, 0);
image2 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image2);
gtk_container_add (GTK_CONTAINER (button_font), image2);
optionmenu1 = gtk_option_menu_new ();
gtk_widget_show (optionmenu1);
gtk_table_attach (GTK_TABLE (table1), optionmenu1, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
menu1 = gtk_menu_new ();
enc_ascii = gtk_menu_item_new_with_mnemonic (_("Ascii"));
gtk_widget_show (enc_ascii);
gtk_container_add (GTK_CONTAINER (menu1), enc_ascii);
/*
enc_8859 = gtk_menu_item_new_with_mnemonic (_("Iso 8859-1 (Czech...)"));
gtk_widget_show (enc_8859);
gtk_container_add (GTK_CONTAINER (menu1), enc_8859);
ebc_cyrillic = gtk_menu_item_new_with_mnemonic (_("Cyrillic"));
gtk_widget_show (ebc_cyrillic);
gtk_container_add (GTK_CONTAINER (menu1), ebc_cyrillic);
enc_german = gtk_menu_item_new_with_mnemonic (_("German"));
gtk_widget_show (enc_german);
gtk_container_add (GTK_CONTAINER (menu1), enc_german);
*/
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1), menu1);
spinbutton_fontsize_adj = gtk_adjustment_new (26, 8, 100, 1, 10, 10);
spinbutton_fontsize = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_fontsize_adj), 1, 0);
gtk_widget_show (spinbutton_fontsize);
gtk_table_attach (GTK_TABLE (table1), spinbutton_fontsize, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton_fontsize), TRUE);
label5 = gtk_label_new (_("Select color"));
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
button_color = gtk_button_new_with_mnemonic (_("Select"));
gtk_widget_show (button_color);
gtk_table_attach (GTK_TABLE (table1), button_color, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
hbox3 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox3);
gtk_box_pack_start (GTK_BOX (vbox1), hbox3, TRUE, TRUE, 0);
drawingarea1 = gtk_drawing_area_new ();
gtk_widget_show (drawingarea1);
gtk_box_pack_start (GTK_BOX (hbox3), drawingarea1, TRUE, TRUE, 0);
gtk_widget_set_size_request (drawingarea1, 352, 288);
vscale1 = gtk_vscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 1, 576, 1, 1, 1)));
gtk_widget_show (vscale1);
gtk_box_pack_start (GTK_BOX (hbox3), vscale1, FALSE, TRUE, 0);
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
applybutton1 = gtk_button_new_from_stock ("gtk-apply");
gtk_widget_show (applybutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), applybutton1, GTK_RESPONSE_APPLY);
GTK_WIDGET_SET_FLAGS (applybutton1, GTK_CAN_DEFAULT);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (dialog1, table1, "table1");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
GLADE_HOOKUP_OBJECT (dialog1, label3, "label3");
GLADE_HOOKUP_OBJECT (dialog1, label4, "label4");
GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (dialog1, label_sub, "label_sub");
GLADE_HOOKUP_OBJECT (dialog1, button_sub, "button_sub");
GLADE_HOOKUP_OBJECT (dialog1, image1, "image1");
GLADE_HOOKUP_OBJECT (dialog1, hbox2, "hbox2");
GLADE_HOOKUP_OBJECT (dialog1, label_font, "label_font");
GLADE_HOOKUP_OBJECT (dialog1, button_font, "button_font");
GLADE_HOOKUP_OBJECT (dialog1, image2, "image2");
GLADE_HOOKUP_OBJECT (dialog1, optionmenu1, "optionmenu1");
GLADE_HOOKUP_OBJECT (dialog1, menu1, "menu1");
GLADE_HOOKUP_OBJECT (dialog1, enc_ascii, "enc_ascii");
/*
GLADE_HOOKUP_OBJECT (dialog1, enc_8859, "enc_8859");
GLADE_HOOKUP_OBJECT (dialog1, ebc_cyrillic, "ebc_cyrillic");
GLADE_HOOKUP_OBJECT (dialog1, enc_german, "enc_german");
*/
GLADE_HOOKUP_OBJECT (dialog1, spinbutton_fontsize, "spinbutton_fontsize");
GLADE_HOOKUP_OBJECT (dialog1, label5, "label5");
GLADE_HOOKUP_OBJECT (dialog1, button_color, "button_color");
GLADE_HOOKUP_OBJECT (dialog1, hbox3, "hbox3");
GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1");
GLADE_HOOKUP_OBJECT (dialog1, vscale1, "vscale1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, applybutton1, "applybutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
PRIVATE void init_2oct_pattern(Control *control) {
GtkWidget *hb;
int i;
GtkWidget **widgets = safe_malloc(sizeof(GtkWidget *) * (SEQUENCE_LENGTH * 2 + 1));
Data *data = control->g->data;
GtkWidget *label, *menu;
GtkWidget *rightvb;
hb = gtk_hbox_new(FALSE, 5);
for (i = 0; i < SEQUENCE_LENGTH; i++) {
GtkWidget *vb = gtk_vbox_new(FALSE, 5);
GtkWidget *b = gtk_vscale_new(NULL);
GtkWidget *t = gtk_toggle_button_new();
GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(b));
gtk_scale_set_draw_value(GTK_SCALE(b), FALSE);
gtk_scale_set_digits(GTK_SCALE(b), 2);
adj->step_increment = 1;
adj->page_increment = 1;
adj->lower = 127 - 48;
adj->upper = 127 - 24;
adj->value = 127 - data->pattern[data->edit][i];
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(t), data->note[data->edit][i]);
gtk_object_set_data(GTK_OBJECT(adj), "Control", control);
gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
GTK_SIGNAL_FUNC(value_changed_handler), (gpointer) i);
gtk_signal_connect(GTK_OBJECT(b), "focus_in_event",
GTK_SIGNAL_FUNC(focus_in_handler), control);
gtk_widget_set_usize(b, 12, 100);
gtk_box_pack_start(GTK_BOX(vb), b, FALSE, FALSE, 0);
gtk_widget_show(b);
widgets[i] = b;
gtk_object_set_data(GTK_OBJECT(t), "Control", control);
gtk_signal_connect(GTK_OBJECT(t), "toggled",
GTK_SIGNAL_FUNC(toggle_changed_handler), (gpointer) i);
gtk_widget_set_usize(t, 12, 16);
gtk_box_pack_start(GTK_BOX(vb), t, FALSE, FALSE, 0);
gtk_widget_show(t);
widgets[i + SEQUENCE_LENGTH] = t;
gtk_box_pack_start(GTK_BOX(hb), vb, FALSE, FALSE, 0);
gtk_widget_show(vb);
}
rightvb = gtk_vbox_new( FALSE, 5 );
label = gtk_label_new("--");
gtk_box_pack_start(GTK_BOX(rightvb), label, FALSE, FALSE, 0);
menu = gtk_button_new_with_label( "M" );
gtk_box_pack_start(GTK_BOX(rightvb), menu, TRUE, FALSE, 0);
gtk_signal_connect( GTK_OBJECT(menu), "clicked",
GTK_SIGNAL_FUNC( popup_handler ), control );
gtk_box_pack_start(GTK_BOX(hb), rightvb, FALSE, FALSE, 0);
gtk_widget_show(label);
gtk_widget_show(menu);
gtk_widget_show(rightvb);
widgets[SEQUENCE_LENGTH * 2] = label;
control->widget = hb;
control->data = widgets;
}
bool createch(void)
{
struct gchan *object;
GtkWidget *fixed;
GtkWidget *frami1;
GtkWidget *vbox, *htast, *hbot;
GtkObject *adj, *adj1;
GtkWidget *playmenu, *playmenuopt;
GtkWidget *tmpwid, *tmpwid1, *dock;
GtkWidget *progress;
GtkWidget *volume;
GtkWidget *scrollwin;
GtkWidget *table, *rmit/*, *file, *http*/;
GtkWidget *piddi;
GtkTreeSelection *select;
GtkListStore *store;
GtkWidget *tree;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTargetEntry target_entry[3];
gchar numchan[16];
unsigned int pos=0;
unsigned int idx=1;
dock=rmit=NULL;
while(( object = (struct gchan *) list_get_data(listachan, idx, 0) ))
idx++;
if(idx > MAX_CHANNELS)
return FALSE;
func(_("GTK_GUI::createch(%u)"), idx);
object = (struct gchan *) g_malloc (sizeof(struct gchan));
object->idx = idx;
object->channel = 0; /* nothing */
func(_("GTK_GUI::createch : chan[%u] is at %p"), idx, object);
mixer->create_channel(idx-1);
snprintf(numchan, 16, _("Channel[%u]"), object->idx);
frami1 = gtk_frame_new(numchan);
object->frami = frami1;
gtk_frame_set_shadow_type(GTK_FRAME(frami1), GTK_SHADOW_ETCHED_OUT);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frami1), vbox);
/* at the moment pos is 0 function */
list_add(&listachan, (void *) object, pos, idx, object->frami);
htast = gtk_hbox_new(TRUE, 0); /* same dimension */
fixed = gtk_fixed_new();
gtk_fixed_put(GTK_FIXED(fixed), htast, 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), fixed, FALSE, FALSE, 0);
/* addiamo il coso del tempo */
tmpwid = gtk_entry_new_with_max_length(9);
object->ptime = tmpwid;
gtk_widget_set_size_request(tmpwid, 55, 22);
gtk_entry_set_text(GTK_ENTRY(tmpwid), "00:00:00");
gtk_entry_set_editable(GTK_ENTRY(tmpwid), FALSE);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, FALSE, 0);
/* enjoy ourselves with buttons */
tmpwid = createpixmap(window, tmpwid, play_xpm,
_("Play Channel"), TRUE);
object->play = tmpwid;
g_signal_connect(G_OBJECT(tmpwid), "pressed",
G_CALLBACK(gcb_play_channel), object);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, TRUE, 0);
tmpwid = createpixmap(window, tmpwid, stop_xpm,
_("Stop Channel"), FALSE);
g_signal_connect(G_OBJECT(tmpwid), "pressed",
G_CALLBACK(gcb_stop_channel), object);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, TRUE, 0);
tmpwid = createpixmap(window, tmpwid, pause_xpm,
_("Pause Channel"), TRUE);
object->pause = tmpwid;
g_signal_connect(G_OBJECT(tmpwid), "clicked",
G_CALLBACK(gcb_pause_channel), object);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, TRUE, 0);
tmpwid = createpixmap(window, tmpwid, rewind_xpm,
_("Rewind Channel"), FALSE);
g_signal_connect(G_OBJECT(tmpwid), "clicked",
G_CALLBACK(gcb_begin_channel), object);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, TRUE, 0);
tmpwid = createpixmap(window, tmpwid, forward_xpm,
_("Forward Channel"), FALSE);
g_signal_connect(G_OBJECT(tmpwid), "clicked",
G_CALLBACK(gcb_end_channel), object);
gtk_box_pack_start(GTK_BOX(htast), tmpwid, FALSE, TRUE, 0);
/* second part */
adj = gtk_adjustment_new(0.0, 0.0, 1.0, 0.1, 0.1, 0.0);
object->adjprog = adj;
progress = gtk_hscale_new(GTK_ADJUSTMENT(adj));
gtk_range_set_update_policy(GTK_RANGE(progress),GTK_UPDATE_DELAYED);
gtk_scale_set_digits(GTK_SCALE(progress), 6);
object->progress = progress;
gtk_scale_set_draw_value(GTK_SCALE(progress), FALSE);
/*
g_signal_connect(G_OBJECT(progress), "button_press_event",
G_CALLBACK(gcb_event_pause_channel), object);
g_signal_connect(G_OBJECT(progress), "button_release_event",
G_CALLBACK(gcb_event_set_position), object);
*/
/* here there is a problem: the position sticks to the mouse
maybe there is a way to say to unfocus the widget after moving it? */
g_signal_connect(G_OBJECT(progress), "button_release_event",
G_CALLBACK(gcb_event_set_position), object);
gtk_box_pack_start(GTK_BOX(vbox), progress, FALSE, FALSE, 0);
hbot = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(vbox), hbot);
/* volume adjustment */
adj1 = gtk_adjustment_new(0.0, 0.0, 1.0, 0.01, 0.01, 0.0);
object->adjvol = adj1;
object->volid = g_signal_connect(G_OBJECT(adj1), "value_changed",
G_CALLBACK(gcb_set_volume), object);
#ifdef WITH_SPEED
/* speed adjustment */
object->adjspeed = gtk_adjustment_new(1.0, 0.0, 1.0, 0.1, 0.1, 0.0);
g_signal_connect(G_OBJECT(object->adjspeed), "value_changed",
G_CALLBACK(gcb_set_speed), object);
#endif
volume = gtk_vscale_new(GTK_ADJUSTMENT(adj1));
gtk_scale_set_draw_value(GTK_SCALE(volume), FALSE);
tmpwid = gtk_table_new(2, 1, FALSE);
gtk_box_pack_start(GTK_BOX(hbot), tmpwid, FALSE, FALSE, 0);
tmpwid1 = gtk_vbox_new(FALSE, 0);
object->vol_lab = gtk_label_new(_("VOL"));
gtk_box_pack_start(GTK_BOX(tmpwid1), object->vol_lab, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(tmpwid1), volume, TRUE, TRUE, 0);
object->vol_lab=gtk_label_new(_("100"));
gtk_box_pack_start(GTK_BOX(tmpwid1), object->vol_lab, FALSE, FALSE, 0);
gtk_table_attach_defaults(GTK_TABLE(tmpwid), tmpwid1, 0, 1, 1, 2);
#ifdef WITH_SPEED
/* speed widget */
// tmpwid1=gtk_vbox_new(FALSE, 0);
object->speed=gtk_tx_dial_new(GTK_ADJUSTMENT(object->adjspeed));
set_tip(object->speed, _("Speed"));
gtk_box_pack_start(GTK_BOX(tmpwid1), object->speed, FALSE, FALSE, 0);
object->speed_lab=gtk_label_new(_("100"));
gtk_box_pack_start(GTK_BOX(tmpwid1), object->speed_lab, FALSE, FALSE, 0);
gtk_table_attach_defaults(GTK_TABLE(tmpwid), tmpwid1, 0, 1, 0, 1);
#endif
scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_size_request(scrollwin, 90, 140);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
store = gtk_list_store_new(N_COLUMNS, G_TYPE_STRING);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
object->tree = tree;
//gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
/* DND stuff */
target_entry[0].target = (gchar *)DRAG_TAR_NAME_0;
target_entry[0].flags = 0;
target_entry[0].info = DRAG_TAR_INFO_0;
target_entry[1].target = (gchar *)DRAG_TAR_NAME_1;
target_entry[1].flags = 0;
target_entry[1].info = DRAG_TAR_INFO_1;
target_entry[2].target = (gchar *)DRAG_TAR_NAME_2;
target_entry[2].flags = 0;
target_entry[2].info = DRAG_TAR_INFO_2;
gtk_drag_dest_set(
tree,
(GtkDestDefaults)(GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT |
GTK_DEST_DEFAULT_DROP),
target_entry,sizeof(target_entry) / sizeof(GtkTargetEntry),
GDK_ACTION_MOVE);
g_signal_connect(G_OBJECT(tree), "drag_motion",
G_CALLBACK(DND_data_motion), object);
gtk_drag_source_set(
tree,
(GdkModifierType) (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK),
target_entry, sizeof(target_entry) / sizeof(GtkTargetEntry),
GDK_ACTION_MOVE);
g_signal_connect(G_OBJECT(tree), "drag_begin",
G_CALLBACK(DND_begin), object);
g_signal_connect(G_OBJECT(tree), "drag_end",
G_CALLBACK(DND_end), object);
g_signal_connect(G_OBJECT(tree), "drag_data_get",
G_CALLBACK(DND_data_get), object);
g_signal_connect(G_OBJECT(tree), "drag_data_received",
G_CALLBACK(DND_data_received), object);
g_signal_connect(G_OBJECT(tree), "drag_data_delete",
G_CALLBACK(DND_data_delete), object);
/* end*/
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
gtk_tree_selection_set_mode (select, GTK_SELECTION_MULTIPLE);
/*g_signal_connect(G_OBJECT(select), "changed",
G_CALLBACK(gcb_set_channel), object);
*/
g_signal_connect(G_OBJECT(tree), "button_press_event",
G_CALLBACK(gcb_event_view_popup), object);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Nick",
renderer, "text", TITLE, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
gtk_container_add(GTK_CONTAINER(scrollwin), tree);
gtk_box_pack_start(GTK_BOX(hbot), scrollwin, TRUE, TRUE, 0);
/* playmode menu */
playmenu = gtk_menu_new();
tmpwid = gtk_menu_item_new_with_label(_("single play"));
gtk_menu_append(GTK_MENU(playmenu), tmpwid);
tmpwid=gtk_menu_item_new_with_label(_("loop"));
gtk_menu_append(GTK_MENU(playmenu), tmpwid);
tmpwid=gtk_menu_item_new_with_label(_("continuous"));
gtk_menu_append(GTK_MENU(playmenu), tmpwid);
playmenuopt = gtk_option_menu_new();
gtk_option_menu_set_menu(GTK_OPTION_MENU(playmenuopt), playmenu);
g_signal_connect(G_OBJECT(playmenuopt), "changed",
G_CALLBACK(gcb_set_playmode), object);
rmit = gtk_button_new();
tmpwid = gtk_image_new_from_stock(GTK_STOCK_CANCEL,
GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_container_add(GTK_CONTAINER(rmit), tmpwid);
object->rmit = rmit;
g_signal_connect(G_OBJECT(object->rmit),"clicked",
G_CALLBACK(gcb_deletech), object);
dock = createpixmap(window, dock, dock_xpm,
_("Undock Channel"), FALSE);
object->dock = dock;
g_signal_connect(G_OBJECT(object->dock), "clicked",
G_CALLBACK(dockchan), object);
piddi = gtk_hbox_new(FALSE, 0);
object->hbox = piddi;
gtk_box_pack_start(GTK_BOX(piddi), rmit, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(piddi), dock, FALSE, FALSE, 0);
table = gtk_table_new(1, 4, TRUE);
object->table = table;
gtk_table_attach_defaults(GTK_TABLE(table), piddi, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table), playmenuopt, 3, 5, 0, 1);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
object->playmode = 0;
/* pack_chan_insert and pos update */
pos = pack_chan_insert(object->frami);
return TRUE;
}
void create_range_controls( void )
{
GtkWidget *window;
GtkWidget *box1, *box2, *box3;
GtkWidget *button;
GtkWidget *scrollbar;
GtkWidget *separator;
GtkWidget *opt, *menu, *item;
GtkWidget *label;
GtkWidget *scale;
GtkObject *adj1, *adj2;
/* Standard window-creating stuff */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
gtk_window_set_title (GTK_WINDOW (window), "range controls");
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
/* value, lower, upper, step_increment, page_increment, page_size */
/* Note that the page_size value only makes a difference for
* scrollbar widgets, and the highest value you'll get is actually
* (upper - page_size). */
adj1 = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
vscale = gtk_vscale_new (GTK_ADJUSTMENT (adj1));
scale_set_default_values (GTK_SCALE (vscale));
gtk_box_pack_start (GTK_BOX (box2), vscale, TRUE, TRUE, 0);
gtk_widget_show (vscale);
box3 = gtk_vbox_new (FALSE, 10);
gtk_box_pack_start (GTK_BOX (box2), box3, TRUE, TRUE, 0);
gtk_widget_show (box3);
/* Reuse the same adjustment */
hscale = gtk_hscale_new (GTK_ADJUSTMENT (adj1));
gtk_widget_set_usize (GTK_WIDGET (hscale), 200, 30);
scale_set_default_values (GTK_SCALE (hscale));
gtk_box_pack_start (GTK_BOX (box3), hscale, TRUE, TRUE, 0);
gtk_widget_show (hscale);
/* Reuse the same adjustment again */
scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adj1));
/* Notice how this causes the scales to always be updated
* continuously when the scrollbar is moved */
gtk_range_set_update_policy (GTK_RANGE (scrollbar),
GTK_UPDATE_CONTINUOUS);
gtk_box_pack_start (GTK_BOX (box3), scrollbar, TRUE, TRUE, 0);
gtk_widget_show (scrollbar);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
/* A checkbutton to control whether the value is displayed or not */
button = gtk_check_button_new_with_label("Display value on scale widgets");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_signal_connect (GTK_OBJECT (button), "toggled",
GTK_SIGNAL_FUNC(cb_draw_value), NULL);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_show (button);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* An option menu to change the position of the value */
label = gtk_label_new ("Scale Value Position:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
opt = gtk_option_menu_new();
menu = gtk_menu_new();
item = make_menu_item ("Top",
GTK_SIGNAL_FUNC(cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_TOP));
gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Bottom", GTK_SIGNAL_FUNC (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_BOTTOM));
gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Left", GTK_SIGNAL_FUNC (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_LEFT));
gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Right", GTK_SIGNAL_FUNC (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_RIGHT));
gtk_menu_append (GTK_MENU (menu), item);
gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0);
gtk_widget_show (opt);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* Yet another option menu, this time for the update policy of the
* scale widgets */
label = gtk_label_new ("Scale Update Policy:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
opt = gtk_option_menu_new();
menu = gtk_menu_new();
item = make_menu_item ("Continuous",
GTK_SIGNAL_FUNC (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_CONTINUOUS));
gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Discontinuous",
GTK_SIGNAL_FUNC (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_DISCONTINUOUS));
gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Delayed",
GTK_SIGNAL_FUNC (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_DELAYED));
gtk_menu_append (GTK_MENU (menu), item);
gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0);
gtk_widget_show (opt);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* An HScale widget for adjusting the number of digits on the
* sample scales. */
label = gtk_label_new ("Scale Digits:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
adj2 = gtk_adjustment_new (1.0, 0.0, 5.0, 1.0, 1.0, 0.0);
gtk_signal_connect (GTK_OBJECT (adj2), "value_changed",
GTK_SIGNAL_FUNC (cb_digits_scale), NULL);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2));
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* And, one last HScale widget for adjusting the page size of the
* scrollbar. */
label = gtk_label_new ("Scrollbar Page Size:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
adj2 = gtk_adjustment_new (1.0, 1.0, 101.0, 1.0, 1.0, 0.0);
gtk_signal_connect (GTK_OBJECT (adj2), "value_changed",
GTK_SIGNAL_FUNC (cb_page_size), adj1);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2));
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
button = gtk_button_new_with_label ("Quit");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (window);
}
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;
}
