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; }