static GtkWidget * scrolledwindow_new (GladeXML *xml, GladeWidgetInfo *info) { GtkWidget *win = gtk_scrolled_window_new(NULL, NULL); GList *tmp; GtkPolicyType hpol = GTK_POLICY_ALWAYS, vpol = GTK_POLICY_ALWAYS; for (tmp = info->attributes; tmp; tmp = tmp->next) { GladeAttribute *attr = tmp->data; if (!strcmp(attr->name, "hscrollbar_policy")) hpol = glade_enum_from_string(GTK_TYPE_POLICY_TYPE, attr->value); else if (!strcmp(attr->name, "hupdate_policy")) gtk_range_set_update_policy( GTK_RANGE(GTK_SCROLLED_WINDOW(win)->hscrollbar), glade_enum_from_string(GTK_TYPE_UPDATE_TYPE, attr->value)); else if (!strcmp(attr->name, "shadow_type")) gtk_viewport_set_shadow_type(GTK_VIEWPORT(win), glade_enum_from_string(GTK_TYPE_SHADOW_TYPE, attr->value)); else if (!strcmp(attr->name, "vscrollbar_policy")) vpol = glade_enum_from_string(GTK_TYPE_POLICY_TYPE, attr->value); else if (!strcmp(attr->name, "vupdate_policy")) gtk_range_set_update_policy( GTK_RANGE(GTK_SCROLLED_WINDOW(win)->vscrollbar), glade_enum_from_string(GTK_TYPE_UPDATE_TYPE, attr->value)); } gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(win), hpol, vpol); return win; }
void cb_update_menu_select( GtkWidget *item, GtkUpdateType policy ) { /* Set the update policy for both scale widgets */ gtk_range_set_update_policy (GTK_RANGE (hscale), policy); gtk_range_set_update_policy (GTK_RANGE (vscale), policy); }
GtkWidget *gui_direct_hscale(gdouble min, gdouble max, gdouble step, gpointer value, gpointer func, gpointer arg, GtkWidget *box) { GtkWidget *hscale; struct model_pak *model; model = sysenv.active_model; g_assert(model != NULL); hscale = gtk_hscale_new_with_range(min, max, step); gtk_range_set_update_policy(GTK_RANGE(hscale), GTK_UPDATE_CONTINUOUS); if (box) gtk_box_pack_start(GTK_BOX(box), hscale, TRUE, TRUE, 0); gui_relation_submit(hscale, AUTO_RANGE, value, TRUE, model); /* callback to set the variable to match the widget */ g_signal_connect(GTK_OBJECT(hscale), "value_changed", GTK_SIGNAL_FUNC(gui_relation_set_value), model); /* user callback */ if (func) g_signal_connect_after(GTK_OBJECT(hscale), "value_changed", GTK_SIGNAL_FUNC(func), arg); /* callback to remove the variable <-> widget relation */ g_signal_connect(GTK_OBJECT(hscale), "destroy", GTK_SIGNAL_FUNC(gui_relation_destroy), NULL); return(hscale); }
void gSlider::init() { GtkAdjustment* adj = gtk_range_get_adjustment(GTK_RANGE(widget)); //if (_min == _max) // _max = _min + 1; if (_value < _min) _value = _min; else if (_value > _max) _value = _max; if (g_typ == Type_gSlider) { gtk_range_set_range(GTK_RANGE(widget), (gdouble)_min, (gdouble)_max); gtk_range_set_increments(GTK_RANGE(widget), (gdouble)_step, (gdouble)_page_step); } else { gtk_range_set_range(GTK_RANGE(widget), (gdouble)_min, (gdouble)_max + _page_step); gtk_range_set_increments(GTK_RANGE(widget), (gdouble)_step, (gdouble)_page_step); gtk_adjustment_set_page_size(adj, _page_step); } gtk_range_set_value(GTK_RANGE(widget), _value); #ifndef GTK3 gtk_range_set_update_policy(GTK_RANGE(widget), _tracking ? GTK_UPDATE_CONTINUOUS : GTK_UPDATE_DISCONTINUOUS); #endif checkInverted(); }
static GtkWidget* gimp_scale_entry_new (GtkWidget *parent_box, gfloat value, gfloat lower, gfloat upper, gfloat step_increment, gfloat page_increment) { GtkWidget *hbox; GtkWidget *scale; GtkWidget *spinbutton; GtkObject *adj; adj = gtk_adjustment_new (value, lower, upper, step_increment, page_increment, 0.0); spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1.0, 0); scale = gtk_hscale_new (GTK_ADJUSTMENT (adj)); gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE); gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED); gtk_widget_set_size_request (GTK_WIDGET (scale), SCALE_SIZE, -1); hbox = gtk_hbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (parent_box), hbox, TRUE, TRUE, 0); gtk_widget_show_all (hbox); return scale; }
void scale_set_default_values( GtkScale *scale ) { gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_CONTINUOUS); gtk_scale_set_digits (scale, 1); gtk_scale_set_value_pos (scale, GTK_POS_TOP); gtk_scale_set_draw_value (scale, TRUE); }
void init_breakpoints() { int i; GtkWidget *boxH1, *scrolledwindow1, *boxV1, *buAdd, *buRemove; breakpoints_opened = 1; for(i=0; i<BREAKPOINTS_MAX_NUMBER; i++) { bp_addresses[i]=0; } for(i=0; i<BREAKPOINTS_MAX_NUMBER; i++) { selected[i]=0; } //=== Creation of Breakpoints Management ===========/ winBreakpoints = gtk_window_new( GTK_WINDOW_TOPLEVEL ); gtk_window_set_title( GTK_WINDOW(winBreakpoints), "Breakpoints"); gtk_window_set_default_size( GTK_WINDOW(winBreakpoints), 100, 150); gtk_container_set_border_width( GTK_CONTAINER(winBreakpoints), 2); boxH1 = gtk_hbox_new( FALSE, 0 ); gtk_container_add( GTK_CONTAINER(winBreakpoints), boxH1 ); //=== Creation of Breakpoints Display ==============/ scrolledwindow1 = gtk_scrolled_window_new( NULL, NULL ); gtk_box_pack_start( GTK_BOX(boxH1), scrolledwindow1, FALSE, FALSE, 0); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC ); gtk_range_set_update_policy( GTK_RANGE (GTK_SCROLLED_WINDOW(scrolledwindow1)->hscrollbar), GTK_POLICY_AUTOMATIC ); clBreakpoints = gtk_clist_new( 1 ); gtk_container_add( GTK_CONTAINER(scrolledwindow1), clBreakpoints ); gtk_clist_set_selection_mode( GTK_CLIST(clBreakpoints), GTK_SELECTION_EXTENDED ); gtk_clist_set_column_width( GTK_CLIST(clBreakpoints), 0, 80 ); gtk_clist_set_auto_sort( GTK_CLIST(clBreakpoints), TRUE ); //=== Creation of the Buttons ======================/ boxV1 = gtk_vbox_new( FALSE, 2 ); gtk_box_pack_end( GTK_BOX(boxH1), boxV1, FALSE, FALSE, 0 ); buAdd = gtk_button_new_with_label("Add"); gtk_box_pack_start( GTK_BOX(boxV1), buAdd, FALSE, FALSE, 0 ); buRemove = gtk_button_new_with_label( "Remove" ); gtk_box_pack_start( GTK_BOX(boxV1), buRemove, FALSE, FALSE, 0 ); gtk_widget_show_all(winBreakpoints); //=== Signal Connections ===========================/ gtk_signal_connect( GTK_OBJECT(clBreakpoints), "select-row", on_row_selection, NULL ); gtk_signal_connect( GTK_OBJECT(clBreakpoints), "unselect-row", on_row_unselection, NULL ); gtk_signal_connect( GTK_OBJECT(buAdd), "clicked", on_add, NULL ); gtk_signal_connect( GTK_OBJECT(buRemove), "clicked", on_remove, NULL ); gtk_signal_connect( GTK_OBJECT(winBreakpoints), "destroy", on_close, NULL ); }
GtkWidget * scaler_new(gdouble low, gdouble high, gdouble prec) { GtkWidget * w; w = gtk_hscale_new_with_range(low,high,prec); gtk_scale_set_value_pos(GTK_SCALE(w),GTK_POS_RIGHT); gtk_range_set_update_policy(GTK_RANGE(w),GTK_UPDATE_DISCONTINUOUS); gtk_widget_set_size_request(w,100,-1); return w; }
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); }
GtkWidget * prefs_slideshow_page (void) { GtkWidget *main_vbox; GtkWidget *frame1; GtkWidget *vbox; GtkWidget *frame2; GtkObject *adjustment; GtkWidget *hscale; main_vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 10); frame1 = gtk_frame_new (_(" Delay before image change: ")); gtk_box_pack_start (GTK_BOX (main_vbox), frame1, FALSE, FALSE, 0); vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 10); gtk_container_add (GTK_CONTAINER (frame1), vbox); frame2 = gtk_frame_new (NULL); gtk_box_pack_start (GTK_BOX (vbox), frame2, FALSE, TRUE, 1); gtk_widget_set_usize (frame2, -2, 30); adjustment = gtk_adjustment_new (5.0, 0.0, (gfloat) nintervals, 1.0, 1.0, 1.0); gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed", GTK_SIGNAL_FUNC (cb_slideshow_interval_scale_changed), NULL); GTK_ADJUSTMENT (adjustment)->value = (gfloat) slideshow_interval_get_index (conf.slideshow_interval); hscale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment)); gtk_range_set_update_policy (GTK_RANGE (hscale), GTK_UPDATE_CONTINUOUS); gtk_scale_set_digits (GTK_SCALE (hscale), 1); gtk_container_add (GTK_CONTAINER (frame2), hscale); gtk_scale_set_draw_value (GTK_SCALE (hscale), FALSE); slideshow_interval_label = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (vbox), slideshow_interval_label, FALSE, FALSE, 3); slideshow_interval_update (conf.slideshow_interval); gtk_widget_show_all (frame1); return main_vbox; }
gScrollBar::gScrollBar(gContainer *par) : gSlider(par, true) { g_typ = Type_gScrollBar; widget = gtk_hscrollbar_new(NULL); realize(false); init(); onChange = NULL; #ifndef GTK3 gtk_range_set_update_policy(GTK_RANGE(widget),GTK_UPDATE_CONTINUOUS); #endif g_signal_connect(G_OBJECT(widget), "value-changed", G_CALLBACK(cb_change), (gpointer)this); }
GtkWidget * create_editor_window(const char *tag) { GtkWidget *window; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkWidget *combo; GtkWidget *separator; GtkWidget *frame; GtkWidget *table; GtkWidget *scale; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); set_window_title(window, tag, "Patch Edit"); g_signal_connect (G_OBJECT(window), "destroy", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (G_OBJECT (window), "delete-event", G_CALLBACK (on_delete_event_wrapper), (gpointer)gtk_widget_hide); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); editor_status_label = gtk_label_new (" "); gtk_container_add (GTK_CONTAINER (vbox), editor_status_label); gtk_misc_set_alignment (GTK_MISC (editor_status_label), 0, 0.5); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox), 0); label = gtk_label_new ("Patch Name"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); editor_name_entry = gtk_entry_new_with_max_length(10); gtk_box_pack_start (GTK_BOX (hbox), editor_name_entry, FALSE, FALSE, 2); g_signal_connect(G_OBJECT(editor_name_entry), "changed", G_CALLBACK(patch_edit_on_name_entry_changed), NULL); /* -FIX- comment (reuse Performance Name?) * GtkWidget *comment_label = gtk_label_new ("Comment"); * gtk_box_pack_start (GTK_BOX (hbox), comment_label, FALSE, FALSE, 2); * gtk_misc_set_alignment (GTK_MISC (comment_label), 0, 0.5); * GtkWidget *comment_entry = gtk_entry_new_with_max_length(60); * gtk_box_pack_start (GTK_BOX (hbox), comment_entry, TRUE, TRUE, 2); */ /* separator */ separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 2); gtk_widget_show_all(vbox); /* editor widgets */ create_widgy_editor(tag); gtk_box_pack_start (GTK_BOX (vbox), widgy_widget, TRUE, FALSE, 2); gtk_widget_show(widgy_widget); create_retro_editor(tag); gtk_box_pack_start (GTK_BOX (vbox), retro_widget, TRUE, FALSE, 2); /* separator */ separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 2); gtk_widget_show(separator); /* edit action widgets */ hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox), 0); label = gtk_label_new ("Editor Mode"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2); combo = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Widgy"); gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Retro"); gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0); gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 2); g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(patch_edit_on_mode_change), NULL); /* -FIX- add: [compare to original?] [swap A/B?] [close?] */ label = gtk_label_new (NULL); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, FALSE, 0); editor_discard_button = gtk_button_new_with_label ("Discard Changes"); gtk_box_pack_start (GTK_BOX (hbox), editor_discard_button, FALSE, FALSE, 2); gtk_signal_connect (GTK_OBJECT (editor_discard_button), "clicked", GTK_SIGNAL_FUNC (on_editor_discard_button_press), NULL); editor_save_button = gtk_button_new_with_label ("Save Changes into Patch Bank"); gtk_box_pack_start (GTK_BOX (hbox), editor_save_button, FALSE, FALSE, 2); gtk_signal_connect (GTK_OBJECT (editor_save_button), "clicked", GTK_SIGNAL_FUNC (on_editor_save_button_press), NULL); gtk_widget_show_all(hbox); /* test note widgets */ frame = gtk_frame_new ("Test Note"); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); table = gtk_table_new (3, 3, FALSE); gtk_container_add (GTK_CONTAINER (frame), table); gtk_container_set_border_width (GTK_CONTAINER (table), 2); gtk_table_set_row_spacings (GTK_TABLE (table), 1); gtk_table_set_col_spacings (GTK_TABLE (table), 5); label = gtk_label_new ("key"); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); scale = gtk_hscale_new (GTK_ADJUSTMENT (test_note_key_adj)); gtk_table_attach (GTK_TABLE (table), scale, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (scale), 0); gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED); label = gtk_label_new ("velocity"); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); scale = gtk_hscale_new (GTK_ADJUSTMENT (test_note_velocity_adj)); gtk_table_attach (GTK_TABLE (table), scale, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (scale), 0); gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED); editor_test_note_button = gtk_button_new_with_label (" Send Test Note"); gtk_table_attach (GTK_TABLE (table), editor_test_note_button, 2, 3, 0, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 4, 0); gtk_button_set_focus_on_click(GTK_BUTTON(editor_test_note_button), FALSE); g_signal_connect (G_OBJECT (editor_test_note_button), "pressed", G_CALLBACK (on_test_note_button_press), (gpointer)1); g_signal_connect (G_OBJECT (editor_test_note_button), "released", G_CALLBACK (on_test_note_button_press), (gpointer)0); gtk_widget_show_all (frame); editor_window = window; return editor_window; }
static int icvCreateTrackbar( const char* trackbar_name, const char* window_name, int* val, int count, CvTrackbarCallback on_notify, CvTrackbarCallback2 on_notify2, void* userdata ) { int result = 0; CV_FUNCNAME( "icvCreateTrackbar" ); __BEGIN__; /*char slider_name[32];*/ CvWindow* window = 0; CvTrackbar* trackbar = 0; if( !window_name || !trackbar_name ) CV_ERROR( CV_StsNullPtr, "NULL window or trackbar name" ); if( count <= 0 ) CV_ERROR( CV_StsOutOfRange, "Bad trackbar maximal value" ); window = icvFindWindowByName(window_name); if( !window ) EXIT; trackbar = icvFindTrackbarByName(window,trackbar_name); CV_LOCK_MUTEX(); if( !trackbar ) { int len = strlen(trackbar_name); trackbar = (CvTrackbar*)cvAlloc(sizeof(CvTrackbar) + len + 1); memset( trackbar, 0, sizeof(*trackbar)); trackbar->signature = CV_TRACKBAR_MAGIC_VAL; trackbar->name = (char*)(trackbar+1); memcpy( trackbar->name, trackbar_name, len + 1 ); trackbar->parent = window; trackbar->next = window->toolbar.first; window->toolbar.first = trackbar; GtkWidget* hscale_box = gtk_hbox_new( FALSE, 10 ); GtkWidget* hscale_label = gtk_label_new( trackbar_name ); GtkWidget* hscale = gtk_hscale_new_with_range( 0, count, 1 ); gtk_range_set_update_policy( GTK_RANGE(hscale), GTK_UPDATE_CONTINUOUS ); gtk_scale_set_digits( GTK_SCALE(hscale), 0 ); //gtk_scale_set_value_pos( hscale, GTK_POS_TOP ); gtk_scale_set_draw_value( GTK_SCALE(hscale), TRUE ); trackbar->widget = hscale; gtk_box_pack_start( GTK_BOX(hscale_box), hscale_label, FALSE, FALSE, 5 ); gtk_widget_show( hscale_label ); gtk_box_pack_start( GTK_BOX(hscale_box), hscale, TRUE, TRUE, 5 ); gtk_widget_show( hscale ); gtk_box_pack_start( GTK_BOX(window->paned), hscale_box, FALSE, FALSE, 5 ); gtk_widget_show( hscale_box ); } if( val ) { int value = *val; if( value < 0 ) value = 0; if( value > count ) value = count; gtk_range_set_value( GTK_RANGE(trackbar->widget), value ); trackbar->pos = value; trackbar->data = val; } trackbar->maxval = count; trackbar->notify = on_notify; trackbar->notify2 = on_notify2; trackbar->userdata = userdata; gtk_signal_connect( GTK_OBJECT(trackbar->widget), "value-changed", GTK_SIGNAL_FUNC(icvOnTrackbar), trackbar ); // queue a widget resize to trigger a window resize to // compensate for the addition of trackbars gtk_widget_queue_resize( GTK_WIDGET(window->widget) ); CV_UNLOCK_MUTEX(); result = 1; __END__; return result; }
GtkWidget* build_gui ( void ) { GtkWidget *window1; GtkWidget *vbox1; GtkWidget *vbox2; GtkWidget *table1; GtkWidget *label1; GtkWidget *label2; GtkWidget *label3; GtkWidget *label4; GtkWidget *radiobutton1; GSList *radiobutton1_group = NULL; GtkWidget *radiobutton2; GtkWidget *entry1; window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window1), "tracking antenna"); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (window1), vbox1); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0); table1 = gtk_table_new (4, 3, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox2), table1, TRUE, TRUE, 0); gtk_table_set_col_spacings (GTK_TABLE (table1), 5); label1 = gtk_label_new ("Azimuth"); gtk_widget_show (label1); gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5); label2 = gtk_label_new ("Elevation"); gtk_widget_show (label2); gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); label3 = gtk_label_new ("Id"); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5); label4 = gtk_label_new ("mode"); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); radiobutton1 = gtk_radio_button_new_with_mnemonic (NULL, "manual"); gtk_widget_show (radiobutton1); gtk_table_attach (GTK_TABLE (table1), radiobutton1, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton1), radiobutton1_group); radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton1)); radiobutton2 = gtk_radio_button_new_with_mnemonic (NULL, "tracking"); gtk_widget_show (radiobutton2); gtk_table_attach (GTK_TABLE (table1), radiobutton2, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton2), radiobutton1_group); radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton2)); azim_scale = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (144.7, 0, 360, 1, 1, 1))); gtk_widget_show (azim_scale); gtk_table_attach (GTK_TABLE (table1), azim_scale, 1, 3, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_range_set_update_policy (GTK_RANGE (azim_scale), GTK_UPDATE_DELAYED); elev_scale = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (32.3, 0, 90, 1, 1, 1))); gtk_widget_show (elev_scale); gtk_table_attach (GTK_TABLE (table1), elev_scale, 1, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); entry1 = gtk_entry_new (); gtk_widget_show (entry1); gtk_table_attach (GTK_TABLE (table1), entry1, 1, 3, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect ((gpointer) radiobutton1, "toggled", G_CALLBACK (on_mode_changed), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (window1, window1, "window1"); GLADE_HOOKUP_OBJECT (window1, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (window1, vbox2, "vbox2"); GLADE_HOOKUP_OBJECT (window1, table1, "table1"); GLADE_HOOKUP_OBJECT (window1, label1, "label1"); GLADE_HOOKUP_OBJECT (window1, label2, "label2"); GLADE_HOOKUP_OBJECT (window1, label3, "label3"); GLADE_HOOKUP_OBJECT (window1, label4, "label4"); GLADE_HOOKUP_OBJECT (window1, radiobutton1, "radiobutton1"); GLADE_HOOKUP_OBJECT (window1, radiobutton2, "radiobutton2"); GLADE_HOOKUP_OBJECT (window1, entry1, "entry1"); return window1; }
void setup_a11y_tabs (GtkBuilder *dialog) { GtkWidget *w; a11y_settings = g_settings_new (A11Y_SCHEMA); /* Accessibility tab */ g_settings_bind (a11y_settings, "enable", WID ("master_enable"), "active", G_SETTINGS_BIND_DEFAULT); w = WID ("stickykeys_enable"); g_settings_bind (a11y_settings, "stickykeys-enable", w, "active", G_SETTINGS_BIND_DEFAULT); g_signal_connect (w, "toggled", G_CALLBACK (stickykeys_enable_toggled_cb), dialog); stickykeys_enable_toggled_cb (w, dialog); g_settings_bind (a11y_settings, "stickykeys-two-key-off", WID ("stickykeys_two_key_off"), "active", G_SETTINGS_BIND_DEFAULT); w = WID ("slowkeys_enable"); g_settings_bind (a11y_settings, "slowkeys-enable", w, "active", G_SETTINGS_BIND_DEFAULT); g_signal_connect (w, "toggled", G_CALLBACK (slowkeys_enable_toggled_cb), dialog); slowkeys_enable_toggled_cb (w, dialog); w = WID ("bouncekeys_enable"); g_settings_bind (a11y_settings, "bouncekeys-enable", w, "active", G_SETTINGS_BIND_DEFAULT); g_signal_connect (w, "toggled", G_CALLBACK (bouncekeys_enable_toggled_cb), dialog); bouncekeys_enable_toggled_cb (w, dialog); g_settings_bind (a11y_settings, "slowkeys-delay", gtk_range_get_adjustment (GTK_RANGE (WID ("slowkeys_delay_slide"))), "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (a11y_settings, "bouncekeys-delay", gtk_range_get_adjustment (GTK_RANGE (WID ("bouncekeys_delay_slide"))), "value", G_SETTINGS_BIND_DEFAULT); w = WID ("notifications_button"); g_signal_connect (w, "clicked", G_CALLBACK (notifications_button_clicked_cb), dialog); /* Mouse Keys tab */ w = WID ("mousekeys_enable"); g_settings_bind (a11y_settings, "mousekeys-enable", w, "active", G_SETTINGS_BIND_DEFAULT); g_signal_connect (w, "toggled", G_CALLBACK (mousekeys_enable_toggled_cb), dialog); mousekeys_enable_toggled_cb (w, dialog); g_settings_bind (a11y_settings, "slowkeys-delay", gtk_range_get_adjustment (GTK_RANGE (WID ("slowkeys_delay_slide"))), "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (a11y_settings, "bouncekeys-delay", gtk_range_get_adjustment (GTK_RANGE (WID ("bouncekeys_delay_slide"))), "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (a11y_settings, "slowkeys-delay", gtk_range_get_adjustment (GTK_RANGE (WID ("slowkeys_delay_slide"))), "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (a11y_settings, "bouncekeys-delay", gtk_range_get_adjustment (GTK_RANGE (WID ("bouncekeys_delay_slide"))), "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (a11y_settings, "mousekeys-accel-time", gtk_range_get_adjustment (GTK_RANGE (WID ("mousekeys_accel_time_slide"))), "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (a11y_settings, "mousekeys-max-speed", gtk_range_get_adjustment (GTK_RANGE (WID ("mousekeys_max_speed_slide"))), "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (a11y_settings, "mousekeys-init-delay", gtk_range_get_adjustment (GTK_RANGE (WID ("mousekeys_init_delay_slide"))), "value", G_SETTINGS_BIND_DEFAULT); #if !GTK_CHECK_VERSION (3, 0, 0) const char *range_names[] = { "slowkeys_delay_slide", "bouncekeys_delay_slide", "mousekeys_accel_time_slide", "mousekeys_max_speed_slide", "mousekeys_init_delay_slide" }; int i; for (i = 0; i < 5; ++i) { gtk_range_set_update_policy (GTK_RANGE (WID (range_names[i])), GTK_UPDATE_DISCONTINUOUS); } #endif }
static void layout(void) { int i; GtkWidget *w; GtkWidget *vbox, *bbox, *tbl, *frm; vbox = create_vbox(win); frm = gtk_frame_new("invert axis"); add_child(vbox, frm); tbl = gtk_table_new(3, 4, FALSE); add_child(frm, tbl); gtk_table_set_row_spacings(GTK_TABLE(tbl), 2); gtk_table_set_col_spacings(GTK_TABLE(tbl), 2); gtk_table_attach_defaults(GTK_TABLE(tbl), gtk_label_new("X"), 1, 2, 0, 1); gtk_table_attach_defaults(GTK_TABLE(tbl), gtk_label_new("Y"), 2, 3, 0, 1); gtk_table_attach_defaults(GTK_TABLE(tbl), gtk_label_new("Z"), 3, 4, 0, 1); gtk_table_attach_defaults(GTK_TABLE(tbl), gtk_label_new("translation"), 0, 1, 1, 2); gtk_table_attach_defaults(GTK_TABLE(tbl), gtk_label_new("rotation"), 0, 1, 2, 3); for(i=0; i<6; i++) { int x = i % 3 + 1; int y = i / 3 + 1; w = gtk_check_button_new(); gtk_table_attach_defaults(GTK_TABLE(tbl), w, x, x + 1, y, y + 1); g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(chk_handler), (void*)i); } /*hbox = create_hbox(vbox);*/ frm = gtk_frame_new("sensitivity"); add_child(vbox, frm); w = gtk_hscale_new_with_range(0.0, 4.0, 0.1); gtk_range_set_update_policy(GTK_RANGE(w), GTK_UPDATE_DELAYED); gtk_range_set_value(GTK_RANGE(w), cfg.sensitivity); gtk_scale_set_value_pos(GTK_SCALE(w), GTK_POS_RIGHT); g_signal_connect(G_OBJECT(w), "value_changed", G_CALLBACK(slider_handler), 0); add_child(frm, w); frm = gtk_frame_new("X11 magellan API"); add_child(vbox, frm); bbox = gtk_hbutton_box_new(); add_child(frm, bbox); w = gtk_button_new_with_label("start"); g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(bn_handler), (void*)0); add_child(bbox, w); w = gtk_button_new_with_label("stop"); g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(bn_handler), (void*)1); add_child(bbox, w); w = gtk_button_new_with_label("check"); g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(bn_handler), (void*)2); add_child(bbox, w); /* w = gtk_check_button_new_with_label("enable X11 magellan API"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), query_x11()); g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(chk_handler), (void*)10); add_child(frm, w); */ frm = gtk_frame_new("misc"); add_child(vbox, frm); bbox = gtk_hbutton_box_new(); add_child(frm, bbox); w = gtk_button_new_with_label("ping daemon"); g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(bn_handler), (void*)3); add_child(bbox, w); bbox = gtk_hbutton_box_new(); add_child(vbox, bbox); /*w = gtk_button_new_from_stock(GTK_STOCK_APPLY); g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(bn_handler), 0); add_child(bbox, w);*/ w = gtk_button_new_from_stock(GTK_STOCK_CLOSE); g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(gtk_main_quit), 0); add_child(bbox, w); }
///_____________________________________________________ /// retrieve gtkwidget through their name /// the aim is to avoid having to modify the glade generated file ///_____________________________________________________ uint8_t bindGUI( void ) { #define ADM_LOOKUP(a,b) a= lookup_widget (guiRootWindow,#b);if(!a) return 0; ADM_LOOKUP(guiDrawingArea,guiDrawing); ADM_LOOKUP(guiSlider,sliderNavigate); sliderAdjustment=gtk_range_get_adjustment (GTK_RANGE(guiSlider)); ADM_LOOKUP(guiMarkA,labelMarkA); ADM_LOOKUP(guiMarkB,labelMarkB); ADM_LOOKUP(guiCurFrame,boxCurFrame); ADM_LOOKUP(guiTotalFrame,labelTotalFrame); ADM_LOOKUP(guiCurTime,boxCurTime); ADM_LOOKUP(guiTotalTime,labelTotalTime); ADM_LOOKUP(guiPreviewToggle,togglebuttonPreview); ADM_LOOKUP(guiOutputToggle,toggleOutput); ADM_LOOKUP(guiAudioToggle,togglebuttonAudio); ADM_LOOKUP(guiVideoToggle,togglebuttonVideo); #undef ADM_LOOKUP // bind menu #define CALLBACK(x,y) gtk_signal_connect(GTK_OBJECT(lookup_widget(guiRootWindow,#x)), "activate", \ GTK_SIGNAL_FUNC(guiCallback), (void *) y) #include "GUI_menumap.h" #undef CALLBACK /// /bind menu // destroy gtk_object_set_data_full(GTK_OBJECT(guiRootWindow), "guiRootWindow", guiRootWindow, (GtkDestroyNotify) destroyCallback); // now add callbacks #define ADD_SIGNAL(a,b,c) gtk_signal_connect(GTK_OBJECT(a),b, \ GTK_SIGNAL_FUNC(guiCallback), (void *) c); ADD_SIGNAL(guiSlider,"value_changed",ACT_Scale); // We need to know when the current frame box has the focus to cancel // shortcuts gtk_signal_connect(GTK_OBJECT(lookup_widget(guiRootWindow,"boxCurFrame")), "focus_in_event", GTK_SIGNAL_FUNC(UI_grabFocus), (void *) NULL); gtk_signal_connect(GTK_OBJECT(lookup_widget(guiRootWindow,"boxCurFrame")), "focus_out_event", GTK_SIGNAL_FUNC(UI_looseFocus), (void *) NULL); // Callbacks for buttons uint32_t nb=sizeof(buttonCallback)/sizeof(buttonCallBack_S); GtkWidget *bt; for(uint32_t i=0;i<nb;i++) { bt= lookup_widget (guiRootWindow,buttonCallback[i].name); if(!bt) { printf("Binding failed for %s\n",buttonCallback[i].name); ADM_assert(0); } ADD_SIGNAL(bt,buttonCallback[i].signal,buttonCallback[i].action); GTK_WIDGET_UNSET_FLAGS (bt, GTK_CAN_FOCUS); } GTK_WIDGET_SET_FLAGS (lookup_widget(guiRootWindow,"boxCurFrame"), GTK_CAN_FOCUS); // set some tuning gtk_widget_set_usize(guiDrawingArea, 512, 288); // hscale GTK_WIDGET_UNSET_FLAGS (guiSlider, GTK_CAN_FOCUS); gtk_widget_show(guiSlider); // And, the size now scales to the width of the window. gtk_widget_set_usize(guiSlider, 0, 0); // Plus, two-decimal precision. gtk_scale_set_digits(GTK_SCALE(guiSlider), 2); // And continuous updates! gtk_range_set_update_policy (GTK_RANGE (guiSlider), GTK_UPDATE_CONTINUOUS); // keyboard events /* gtk_signal_connect_after(GTK_OBJECT(guiRootWindow), "key_press_event", GTK_SIGNAL_FUNC(UI_on_key_press), NULL); */ gtk_signal_connect(GTK_OBJECT(guiDrawingArea), "expose_event", GTK_SIGNAL_FUNC(on_drawingarea1_expose_event), NULL); // Finally add video codec... uint32_t nbVid; const char *name; GtkWidget *menuv; menuv = gtk_menu_new (); nbVid=encoderGetNbEncoder(); GtkWidget *vidWidget[nbVid]; printf("Found %d video encoder\n",nbVid); for(uint32_t i=0;i<nbVid;i++) { name=encoderGetIndexedName(i); vidWidget[i]=gtk_menu_item_new_with_mnemonic(name); gtk_widget_show (vidWidget[i]); gtk_container_add (GTK_CONTAINER (menuv), vidWidget[i]); } gtk_option_menu_set_menu (GTK_OPTION_MENU (lookup_widget(guiRootWindow,"optionVCodec")), menuv); // And A codec // Finally add video codec... uint32_t nbAud; GtkWidget *menua; menua = gtk_menu_new (); nbAud=audioFilterGetNbEncoder(); GtkWidget *audWidget[nbAud]; printf("Found %d audio encoder\n",nbAud); for(uint32_t i=0;i<nbAud;i++) { name=audioFilterGetIndexedName(i); audWidget[i]=gtk_menu_item_new_with_mnemonic(name); gtk_widget_show (audWidget[i]); gtk_container_add (GTK_CONTAINER (menua), audWidget[i]); } gtk_option_menu_set_menu (GTK_OPTION_MENU (lookup_widget(guiRootWindow,"optionACodec")), menua); // // //CYB 2005.02.22: DND (START) // Set up avidemux as an available drag'n'drop target. gtk_drag_dest_set(guiRootWindow, GTK_DEST_DEFAULT_ALL, target_table,sizeof(target_table)/sizeof(GtkTargetEntry), (GdkDragAction)(GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_DEFAULT)); g_signal_connect(GTK_OBJECT(guiRootWindow), "drag_data_received", GTK_SIGNAL_FUNC(DNDDataReceived),NULL); //CYB 2005.02.22: DND (END) return 1; }
///_____________________________________________________ /// retrieve gtkwidget through their name /// the aim is to avoid having to modify the glade generated file ///_____________________________________________________ uint8_t bindGUI( void ) { #define ADM_LOOKUP(a,b) a= lookup_widget (guiRootWindow,#b);if(!a) return 0; ADM_LOOKUP(guiDrawingArea,guiDrawing); ADM_LOOKUP(guiSlider,sliderNavigate); sliderAdjustment=gtk_range_get_adjustment (GTK_RANGE(guiSlider)); ADM_LOOKUP(guiMarkA,labelMarkA); ADM_LOOKUP(guiMarkB,labelMarkB); ADM_LOOKUP(guiCurFrame,boxCurFrame); ADM_LOOKUP(guiTotalFrame,labelTotalFrame); ADM_LOOKUP(guiCurTime,boxCurTime); ADM_LOOKUP(guiTotalTime,labelTotalTime); #if 0 ADM_LOOKUP(guiPreviewToggle,toggletoolbuttonPreview); ADM_LOOKUP(guiOutputToggle,toggletoolbuttonOutput); ADM_LOOKUP(guiAudioToggle,togglebuttonAudio); ADM_LOOKUP(guiVideoToggle,togglebuttonVideo); #endif #undef ADM_LOOKUP // bind menu #define CALLBACK(x,y) gtk_signal_connect(GTK_OBJECT(lookup_widget(guiRootWindow,#x)), "activate", \ GTK_SIGNAL_FUNC(guiCallback), (void *) y) #include "GUI_menumap.h" #undef CALLBACK /// /bind menu // destroy gtk_object_set_data_full(GTK_OBJECT(guiRootWindow), "guiRootWindow", guiRootWindow, (GtkDestroyNotify) destroyCallback); // now add callbacks gtk_widget_add_events(guiRootWindow, GDK_BUTTON_PRESS_MASK); gtk_signal_connect(GTK_OBJECT(guiRootWindow), "button_press_event", GTK_SIGNAL_FUNC(UI_returnFocus), NULL); gtk_signal_connect(GTK_OBJECT(guiSlider), "button_press_event", GTK_SIGNAL_FUNC(UI_SliderPressed), NULL); gtk_signal_connect(GTK_OBJECT(guiSlider), "button_release_event", GTK_SIGNAL_FUNC(UI_SliderReleased), NULL); // Current Frame gtk_signal_connect(GTK_OBJECT(guiCurFrame), "focus_in_event", GTK_SIGNAL_FUNC(UI_grabFocus), (void *) NULL); gtk_signal_connect(GTK_OBJECT(guiCurFrame), "focus_out_event", GTK_SIGNAL_FUNC(UI_loseFocus), (void *) NULL); gtk_signal_connect(GTK_OBJECT(guiCurFrame), "activate", GTK_SIGNAL_FUNC(UI_focusAfterActivate), (void *) ACT_JumpToFrame); // Volume gtk_signal_connect(GTK_OBJECT(lookup_widget(guiRootWindow,"hscalVolume")), "value_changed", GTK_SIGNAL_FUNC(volumeChange), (void *) NULL); // Jog gtk_signal_connect(GTK_OBJECT(lookup_widget(guiRootWindow,"jogg")), "value_changed", GTK_SIGNAL_FUNC(jogChange), (void *) NULL); // Time Shift gtk_signal_connect(GTK_OBJECT(lookup_widget(guiRootWindow,"spinbuttonTimeShift")), "focus_in_event", GTK_SIGNAL_FUNC(UI_grabFocus), (void *) NULL); gtk_signal_connect(GTK_OBJECT(lookup_widget(guiRootWindow,"spinbuttonTimeShift")), "focus_out_event", GTK_SIGNAL_FUNC(UI_loseFocus), (void *) NULL); gtk_signal_connect(GTK_OBJECT(lookup_widget(guiRootWindow,"spinbuttonTimeShift")), "activate", GTK_SIGNAL_FUNC(UI_focusAfterActivate), (void *) ACT_TimeShift); #define ADD_SIGNAL(a,b,c) gtk_signal_connect(GTK_OBJECT(a), b, GTK_SIGNAL_FUNC(guiCallback), (void *) c); ADD_SIGNAL(guiSlider,"value_changed",ACT_Scale); ADD_SIGNAL(lookup_widget(guiRootWindow,"spinbuttonTimeShift"),"value_changed",ACT_TimeShift); // Callbacks for buttons uint32_t nb=sizeof(buttonCallback)/sizeof(buttonCallBack_S); GtkWidget *bt; for(uint32_t i=0;i<nb;i++) { bt= lookup_widget (guiRootWindow,buttonCallback[i].name); if(!bt) { printf("Binding failed for %s\n",buttonCallback[i].name); ADM_assert(0); } ADD_SIGNAL(bt,buttonCallback[i].signal,buttonCallback[i].action); GTK_WIDGET_UNSET_FLAGS (bt, GTK_CAN_FOCUS); } GTK_WIDGET_SET_FLAGS (lookup_widget(guiRootWindow,"boxCurFrame"), GTK_CAN_FOCUS); // set some tuning gtk_widget_set_usize(guiDrawingArea, 512, 288); // hscale GTK_WIDGET_UNSET_FLAGS (guiSlider, GTK_CAN_FOCUS); gtk_widget_show(guiSlider); // And, the size now scales to the width of the window. gtk_widget_set_usize(guiSlider, 0, 0); // Plus, two-decimal precision. gtk_scale_set_digits(GTK_SCALE(guiSlider), 2); // And continuous updates! gtk_range_set_update_policy (GTK_RANGE (guiSlider), GTK_UPDATE_CONTINUOUS); gtk_range_set_range(GTK_RANGE(guiSlider),0,100.00); // keyboard events gtk_signal_connect(GTK_OBJECT(guiDrawingArea), "expose_event", GTK_SIGNAL_FUNC(on_drawingarea1_expose_event), NULL); // Finally add video codec... uint32_t nbVid; const char *name; GtkComboBox *combo_box; nbVid=encoderGetNbEncoder(); combo_box=GTK_COMBO_BOX(lookup_widget(guiRootWindow,VIDEO_WIDGET)); gtk_combo_box_remove_text(combo_box,0); printf("Found %d video encoder\n",nbVid); for(uint32_t i=0;i<nbVid;i++) { name=encoderGetIndexedName(i); gtk_combo_box_append_text (combo_box,QT_TR_NOOP(name)); } gtk_combo_box_set_active(combo_box,0); on_video_change(); // And A codec // Finally add video codec... uint32_t nbAud; nbAud=audioFilterGetNbEncoder(); combo_box=GTK_COMBO_BOX(lookup_widget(guiRootWindow,AUDIO_WIDGET)); gtk_combo_box_remove_text(combo_box,0); printf("Found %d audio encoder\n",nbAud); for(uint32_t i=0;i<nbAud;i++) { name=audioFilterGetIndexedName(i); gtk_combo_box_append_text (combo_box,QT_TR_NOOP(name)); } gtk_combo_box_set_active(combo_box,0); on_audio_change(); /* Fill in output format window */ uint32_t nbFormat; nbFormat=sizeof(ADM_allOutputFormat)/sizeof(ADM_FORMAT_DESC); combo_box=GTK_COMBO_BOX(lookup_widget(guiRootWindow,FORMAT_WIDGET)); gtk_combo_box_remove_text(combo_box,0); printf("Found %d Format \n",nbFormat); for(uint32_t i=0;i<nbFormat;i++) { gtk_combo_box_append_text (combo_box,QT_TR_NOOP(ADM_allOutputFormat[i].text)); } gtk_combo_box_set_active(combo_box,0); /* File in preview mode combobox */ const char *previewText[]= { QT_TR_NOOP("Input"), QT_TR_NOOP("Output"), QT_TR_NOOP("Side"), QT_TR_NOOP("Top"), QT_TR_NOOP("Separate") }; combo_box=GTK_COMBO_BOX(lookup_widget(guiRootWindow,PREVIEW_WIDGET)); gtk_combo_box_remove_text(combo_box,0); for(uint32_t i=0;i<sizeof(previewText)/sizeof(char*);i++) { name=previewText[i]; gtk_combo_box_append_text (combo_box,(name)); } gtk_combo_box_set_active(combo_box,0); // Format gtk_combo_box_set_active(GTK_COMBO_BOX(lookup_widget(guiRootWindow,FORMAT_WIDGET)),0); // gtk_signal_connect(GTK_OBJECT(lookup_widget(guiRootWindow,VIDEO_WIDGET)), "changed", GTK_SIGNAL_FUNC(on_video_change), NULL); gtk_signal_connect(GTK_OBJECT(lookup_widget(guiRootWindow,AUDIO_WIDGET)), "changed", GTK_SIGNAL_FUNC(on_audio_change), NULL); gtk_signal_connect(GTK_OBJECT(lookup_widget(guiRootWindow,PREVIEW_WIDGET)), "changed", GTK_SIGNAL_FUNC(on_preview_change), NULL); gtk_signal_connect(GTK_OBJECT(lookup_widget(guiRootWindow,FORMAT_WIDGET)), "changed", GTK_SIGNAL_FUNC(on_format_change), NULL); // Add initial recent files UI_updateRecentMenu( ); // //CYB 2005.02.22: DND (START) // Set up avidemux as an available drag'n'drop target. gtk_drag_dest_set(guiRootWindow, GTK_DEST_DEFAULT_ALL, target_table,sizeof(target_table)/sizeof(GtkTargetEntry), (GdkDragAction)(GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_DEFAULT)); g_signal_connect(GTK_OBJECT(guiRootWindow), "drag_data_received", GTK_SIGNAL_FUNC(DNDDataReceived),NULL); //CYB 2005.02.22: DND (END) // Allow shrink //GTK_WINDOW ( guiRootWindow ) ->allow_shrink = FALSE; //GTK_WINDOW ( guiDrawingArea ) ->allow_shrink = FALSE; // By default enable arrow keys UI_arrow_enabled(); // Add custom menu GUI_initCustom(); return 1; }
spin_button_ctx_t *time_scrollbar_new(void) { GtkObject *adj_msec; GtkObject *adj_sec; GtkObject *adj_min; GtkObject *adj_scale; GtkWidget *scale; GtkWidget *spin_msec; GtkWidget *spin_sec; GtkWidget *spin_min; GtkWidget *hbox; GtkWidget *vbox; spin_button_ctx_t *sbctx; sbctx = (spin_button_ctx_t *) calloc(1, sizeof(spin_button_ctx_t)); vbox = gtk_vbox_new(FALSE, 4); sbctx->time_scrollbar = vbox; hbox = gtk_hbox_new(FALSE, 4); gtk_widget_show(hbox); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0); adj_msec = gtk_adjustment_new(0.0, -1.0, 1000.0, 1.0, 1.0, 1.0); adj_sec = gtk_adjustment_new(0.0, -1.0, 60.0, 1.0, 1.0, 1.0); adj_min = gtk_adjustment_new(0.0, 0.0, 99.0, 1.0, 1.0, 1.0); adj_scale = gtk_adjustment_new(0.0, 0.0, 100.0*60*1000, 5.0, 5.0, 1.0); spin_min = gtk_spin_button_new(GTK_ADJUSTMENT(adj_min), 1.0, 0); gtk_widget_show(spin_min); spin_sec = gtk_spin_button_new(GTK_ADJUSTMENT(adj_sec), 1.0, 0); gtk_widget_show(spin_sec); spin_msec = gtk_spin_button_new(GTK_ADJUSTMENT(adj_msec), 1.0, 0); gtk_widget_show(spin_msec); scale = gtk_hscale_new_with_range(0.0, 100.0, 1.0); gtk_widget_show(scale); gtk_range_set_adjustment(GTK_RANGE(scale), GTK_ADJUSTMENT(adj_scale)); gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_DELAYED); gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE); gtk_box_pack_start(GTK_BOX(hbox), spin_min, FALSE, TRUE, 2); gtk_box_pack_start(GTK_BOX(hbox), spin_sec, FALSE, TRUE, 2); gtk_box_pack_start(GTK_BOX(hbox), spin_msec, FALSE, TRUE, 2); gtk_box_pack_start(GTK_BOX(vbox), scale, FALSE, TRUE, 2); sbctx->spin_min = GTK_SPIN_BUTTON(spin_min); sbctx->spin_sec = GTK_SPIN_BUTTON(spin_sec); sbctx->spin_msec = GTK_SPIN_BUTTON(spin_msec); sbctx->scale = GTK_SCALE(scale); sbctx->adj_min = GTK_ADJUSTMENT(adj_min); sbctx->adj_sec = GTK_ADJUSTMENT(adj_sec); sbctx->adj_msec = GTK_ADJUSTMENT(adj_msec); sbctx->adj_scale = GTK_ADJUSTMENT(adj_scale); g_signal_connect(G_OBJECT(spin_msec), "value-changed", G_CALLBACK(cb_block_scale), sbctx); sbctx->hmsec = g_signal_connect(G_OBJECT(spin_msec), "value-changed", G_CALLBACK(cb_spin_msec), sbctx); g_signal_connect(G_OBJECT(spin_msec), "value-changed", G_CALLBACK(cb_unblock_scale), sbctx); g_signal_connect(G_OBJECT(spin_sec), "value-changed", G_CALLBACK(cb_block_scale), sbctx); sbctx->hsec = g_signal_connect(G_OBJECT(spin_sec), "value-changed", G_CALLBACK(cb_spin_sec), sbctx); g_signal_connect(G_OBJECT(spin_sec), "value-changed", G_CALLBACK(cb_unblock_scale), sbctx); g_signal_connect(G_OBJECT(spin_min), "value-changed", G_CALLBACK(cb_block_scale), sbctx); sbctx->hmin = g_signal_connect(G_OBJECT(spin_min), "value-changed", G_CALLBACK(cb_spin_min), sbctx); g_signal_connect(G_OBJECT(spin_min), "value-changed", G_CALLBACK(cb_unblock_scale), sbctx); g_signal_connect(G_OBJECT(scale), "value-changed", G_CALLBACK(cb_block_spinners), sbctx); sbctx->hscale = g_signal_connect(G_OBJECT(scale), "value-changed", G_CALLBACK(cb_scale), sbctx); g_signal_connect(G_OBJECT(scale), "value-changed", G_CALLBACK(cb_unblock_spinners), sbctx); return sbctx; }
CTopographicMap3DView::CTopographicMap3DView(CTopographicMap3DDisplay& rTopographicMap3DDisplay, CTopographicMapDatabase& rTopographicMapDatabase, uint64 ui64DefaultInterpolation, float64 f64Delay) : m_rTopographicMap3DDisplay(rTopographicMap3DDisplay), m_rTopographicMapDatabase(rTopographicMapDatabase), m_f64MaxDelay(2.0), //maximum delay : 2s m_pBuilderInterface(NULL), m_ui64CurrentInterpolation(ui64DefaultInterpolation), m_pMapPotentials(NULL), m_pMapCurrents(NULL), m_pElectrodesToggleButton(NULL), m_bElectrodesToggledOn(false)//, //m_pSamplingPointsToggleButton(NULL), //m_bSamplingPointsToggledOn(false) { //load the gtk builder interface m_pBuilderInterface=gtk_builder_new(); // glade_xml_new(OpenViBE::Directories::getDataDir() + "/openvibe-plugins/simple-visualisation/openvibe-simple-visualisation-TopographicMap3D.ui", NULL, NULL); gtk_builder_add_from_file(m_pBuilderInterface, OpenViBE::Directories::getDataDir() + "/openvibe-plugins/simple-visualisation/openvibe-simple-visualisation-TopographicMap3D.ui", NULL); if(!m_pBuilderInterface) { g_warning("Couldn't load the interface!"); return; } gtk_builder_connect_signals(m_pBuilderInterface, NULL); //toolbar //------- //get pointers to interpolation type buttons m_pMapPotentials = GTK_RADIO_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "MapPotentials")); m_pMapCurrents = GTK_RADIO_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "MapCurrents")); g_signal_connect(G_OBJECT(m_pMapPotentials), "toggled", G_CALLBACK (setInterpolationCallback), this); g_signal_connect(G_OBJECT(m_pMapCurrents), "toggled", G_CALLBACK (setInterpolationCallback), this); //get pointer to electrodes toggle button m_pElectrodesToggleButton = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "ToggleElectrodes")); //disable electrodes by default m_bElectrodesToggledOn = false; gtk_toggle_tool_button_set_active(m_pElectrodesToggleButton, m_bElectrodesToggledOn); //connect callback g_signal_connect(G_OBJECT(m_pElectrodesToggleButton), "toggled", G_CALLBACK(toggleElectrodesCallback), this); //get pointer to sampling points toggle button //m_pSamplingPointsToggleButton = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "ToggleSamplingPoints")); //disable sampling points by default //m_bSamplingPointsToggledOn = false; //gtk_toggle_tool_button_set_active(m_pSamplingPointsToggleButton, m_bSamplingPointsToggledOn); //connect callback //g_signal_connect(G_OBJECT(m_pSamplingPointsToggleButton), "toggled", G_CALLBACK(toggleSamplingPointsCallback), this); //tell database about maximum delay m_rTopographicMapDatabase.adjustNumberOfDisplayedBuffers(m_f64MaxDelay); //ensure default delay lies in [0, m_f64MaxDelay] if(f64Delay > m_f64MaxDelay) { f64Delay = m_f64MaxDelay; } //set default delay setDelayCB(f64Delay); //configure delay slider GtkWidget* l_pDelayScale = gtk_hscale_new_with_range(0.0, m_f64MaxDelay, 0.1); gtk_range_set_value(GTK_RANGE(l_pDelayScale), f64Delay); gtk_scale_set_value_pos(GTK_SCALE(l_pDelayScale), GTK_POS_TOP); gtk_range_set_update_policy(GTK_RANGE(l_pDelayScale), GTK_UPDATE_CONTINUOUS); gtk_widget_set_size_request(l_pDelayScale, 100, -1); gtk_widget_show_all(l_pDelayScale); g_signal_connect(G_OBJECT(l_pDelayScale), "value_changed", G_CALLBACK(setDelayCallback), this); //replace existing scale (which somehow can't be used) with the newly created one GtkWidget* l_pOldScale = GTK_WIDGET(gtk_builder_get_object(m_pBuilderInterface, "DelayScale")); GtkWidget* l_pScaleParent = gtk_widget_get_parent(l_pOldScale); if(l_pScaleParent != NULL && GTK_IS_CONTAINER(l_pScaleParent)) { gtk_container_remove(GTK_CONTAINER(l_pScaleParent), l_pOldScale); if(GTK_IS_BOX(l_pScaleParent)) { gtk_box_pack_start(GTK_BOX(l_pScaleParent), l_pDelayScale, TRUE, TRUE, 0); gtk_box_reorder_child(GTK_BOX(l_pScaleParent), l_pDelayScale, 0); } } }
static void on_file_save_filter_changed(GObject* obj, GParamSpec* pspec, gpointer user_data) { GtkFileChooser* dlg = (GtkFileChooser*)obj; GtkFileFilter* filter = gtk_file_chooser_get_filter( dlg ); const char* type = (const char*)g_object_get_data(G_OBJECT(filter), "type"); GtkWidget* extra = gtk_file_chooser_get_extra_widget(dlg); if(extra) { gtk_file_chooser_set_extra_widget(dlg, NULL); extra = NULL; } if( type ) { GtkWidget* label, *label2; GtkWidget* scale; if( strcmp( type, "jpeg" ) == 0 ) { extra = gtk_hbox_new(FALSE, 12); label = gtk_label_new(_("JPEG Quality:")); label2 = gtk_label_new(_("Lower quality values yield smaller file sizes,\nbut the image quality will be poorer.")); scale = gtk_hscale_new_with_range( 0, 100, 5 ); gtk_range_set_value(GTK_RANGE(scale), pref.jpg_quality); #if GTK_CHECK_VERSION(2, 24, 0) #else gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_DISCONTINUOUS); #endif g_signal_connect(G_OBJECT(scale), "value-changed", G_CALLBACK(on_int_val_changed), &pref.jpg_quality); gtk_scale_set_draw_value(GTK_SCALE(scale), TRUE); gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_RIGHT); gtk_box_pack_start(GTK_BOX(extra), label, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(extra), scale, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(extra), label2, FALSE, TRUE, 0); } else if( strcmp( type, "png" ) == 0 ) { extra = gtk_hbox_new(FALSE, 12); label = gtk_label_new(_("PNG Compression Level:")); label2 = gtk_label_new(_("Higher compression levels yield smaller file sizes,\nbut takes more time to do the compression.")); scale = gtk_hscale_new_with_range( 0, 9, 1 ); gtk_range_set_value(GTK_RANGE(scale), pref.png_compression); #if GTK_CHECK_VERSION(2, 24, 0) #else gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_DISCONTINUOUS); #endif g_signal_connect(G_OBJECT(scale), "value-changed", G_CALLBACK(on_int_val_changed), &pref.png_compression); gtk_scale_set_draw_value(GTK_SCALE(scale), TRUE); gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_RIGHT); gtk_box_pack_start(GTK_BOX(extra), label, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(extra), scale, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(extra), label2, FALSE, TRUE, 0); } /* FIXME: provide "depth settings for *.ico files" */ if( extra ) { gtk_widget_show_all(extra); gtk_file_chooser_set_extra_widget(dlg, extra); } } }
int main (int argc, char **argv) { GtkWidget *window, *table, *portplot_area_container, *countplot_area_container, *buttonbox; // Containers GtkWidget *portplot, *countplot, *zoom, *zoomlabel, *soundonoff, *soundlabel, *about, *quit; // Actual buttons gint x, y; guchar *pos; // Initialize variables packetcount = 0; sound_fd = -1; sound_onoff = FALSE; zoom_onoff = FALSE; //gnome_init("leak", VERSION, argc, argv); gtk_init(&argc, &argv); gdk_rgb_init(); // Initialize the window window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW (window), "The leak"); gtk_signal_connect(GTK_OBJECT (window), "delete_event", GTK_SIGNAL_FUNC(delete_event_close), NULL); // Set up containers table = gtk_table_new(4, 1, FALSE); gtk_container_add(GTK_CONTAINER (window), table); buttonbox = gtk_vbox_new(FALSE, 0); gtk_table_attach(GTK_TABLE (table), buttonbox, 3, 4, 0, 1, GTK_FILL, GTK_FILL, 0, 0); // Set up drawing areas countplot_area_container = gtk_event_box_new(); countplot = gtk_drawing_area_new(); gtk_container_add(GTK_CONTAINER (countplot_area_container), countplot); gtk_container_set_border_width(GTK_CONTAINER (countplot_area_container), 2); gtk_drawing_area_size(GTK_DRAWING_AREA (countplot), PORT_WIDTH, PORT_HEIGHT); gtk_signal_connect(GTK_OBJECT (countplot), "expose-event", GTK_SIGNAL_FUNC (on_countplot_expose), NULL); gtk_table_attach(GTK_TABLE (table), countplot_area_container, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); portplot_area_container = gtk_event_box_new(); portplot = gtk_drawing_area_new(); gtk_container_add(GTK_CONTAINER (portplot_area_container), portplot); gtk_container_set_border_width(GTK_CONTAINER (portplot_area_container), 2); gtk_drawing_area_size(GTK_DRAWING_AREA (portplot), PORT_WIDTH, PORT_HEIGHT); gtk_signal_connect(GTK_OBJECT (portplot), "expose-event", GTK_SIGNAL_FUNC (on_portplot_expose), NULL); gtk_signal_connect(GTK_OBJECT (portplot_area_container), "button_press_event", GTK_SIGNAL_FUNC (grap_location), NULL); gtk_table_attach(GTK_TABLE (table), portplot_area_container, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0); // Zoom button zoomlabel = gtk_label_new("Zoom In"); zoom = gtk_button_new(); gtk_container_add(GTK_CONTAINER (zoom), zoomlabel); gtk_box_pack_start(GTK_BOX (buttonbox), zoom, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER (zoom), 0); gtk_signal_connect(GTK_OBJECT (zoom), "clicked", GTK_SIGNAL_FUNC(change_zoom_state), zoomlabel); // Sound button soundlabel = gtk_label_new("Activate\nAudio"); soundonoff = gtk_button_new(); gtk_container_add(GTK_CONTAINER (soundonoff), soundlabel); gtk_container_set_border_width(GTK_CONTAINER (soundonoff), 0); gtk_box_pack_start(GTK_BOX (buttonbox), soundonoff, FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT (soundonoff), "clicked", GTK_SIGNAL_FUNC(change_sound_state), soundlabel); // About button // Commented out for lack of Gnome support /* about = gtk_button_new_with_label("About..."); gtk_container_set_border_width(GTK_CONTAINER (about), 0); gtk_box_pack_start(GTK_BOX (buttonbox), about, FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT (about), "clicked", GTK_SIGNAL_FUNC(display_about), NULL); */ // Quit button quit = gtk_button_new_with_label("Quit"); gtk_container_set_border_width(GTK_CONTAINER (quit), 0); gtk_box_pack_start(GTK_BOX (buttonbox), quit, FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT (quit), "clicked", GTK_SIGNAL_FUNC(delete_event_close), NULL); // Scroll bar scroll_params = gtk_adjustment_new(1.0, 1, 1, 0, 0, 0); zoomscroll = gtk_vscrollbar_new(GTK_ADJUSTMENT (scroll_params)); gtk_table_attach(GTK_TABLE (table), zoomscroll, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_range_set_update_policy(GTK_RANGE (zoomscroll), GTK_UPDATE_DISCONTINUOUS); gtk_signal_connect(GTK_OBJECT (scroll_params), "value_changed", GTK_SIGNAL_FUNC(change_scroll_value), portplot); gtk_widget_show_all (window); // The speed issues is due to the parameters passed // to open_live. We have to optimize pcap_d = pcap_open_live("eth0",100,0,75,ebuf); gtk_idle_add((GtkFunction)packet_received,portplot); gtk_timeout_add(200,(GtkFunction)decay_portplot,portplot); gtk_timeout_add(3000, (GtkFunction)decay_countplot, countplot); gtk_main(); return 0; }
void uade_gui_seek_subsong(int to) { GtkWidget *seek_button_box; GtkWidget *prev_next_button_box; GtkWidget *seek_button_vbox; GtkWidget *seek_slider_box; GtkWidget *hscale; GtkWidget *prev_button; GtkWidget *prev_button_frame; GtkWidget *frame; GtkWidget *maxsong_label; GtkWidget *next_button,*ffwd_button; GtkWidget *ffwd_button_frame; if (!uade_thread_running) { fprintf(stderr, "uade: BUG! Seek not possible.\n"); return; } if (seekpopup == NULL) { /* uade's subsong popup */ seekpopup = gtk_window_new(GTK_WINDOW_DIALOG); gtk_window_set_title(GTK_WINDOW(seekpopup), "UADE seek subsong"); gtk_window_set_position(GTK_WINDOW(seekpopup), GTK_WIN_POS_MOUSE); gtk_container_set_border_width(GTK_CONTAINER(seekpopup), 0); gtk_window_set_policy(GTK_WINDOW(seekpopup), FALSE, FALSE, FALSE); gtk_signal_connect(GTK_OBJECT(seekpopup), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &seekpopup); gtk_signal_connect(GTK_OBJECT(seekpopup), "focus_out_event", GTK_SIGNAL_FUNC(focus_out_event), NULL); gtk_widget_realize(seekpopup); gdk_window_set_decorations(seekpopup->window, 0); /* define Slider code, will be used by all styles of the popup */ if (uade_get_max_subsong(-1) >= 0) { subsong_adj = gtk_adjustment_new(uade_get_cur_subsong(0), uade_get_min_subsong(0), uade_get_max_subsong(0), 1, 0, 0); /*our scale for the subsong slider */ maxsong_label = gtk_label_new(g_strdup_printf("%d", uade_get_max_subsong(0))); /* until we can't get the reliable maximum number of subsongs this has to do :-) */ gtk_widget_set_usize(maxsong_label, 24, -1); } else { subsong_adj = gtk_adjustment_new(uade_get_cur_subsong(0), uade_get_min_subsong(0), (uade_get_max_subsong(0)) + 10, 1, 0, 0); /*our scale for the subsong slider */ /*currently: min - min+10 */ maxsong_label = gtk_label_new("..."); /* until we can't get the reliable maximum number of subsongs this has to do :-) */ gtk_widget_set_usize(maxsong_label, 24, -1); } hscale = gtk_hscale_new(GTK_ADJUSTMENT(subsong_adj)); gtk_widget_set_usize(hscale, 160, -1); gtk_scale_set_digits(GTK_SCALE(hscale), 0); gtk_scale_set_value_pos(GTK_SCALE(hscale), GTK_POS_LEFT); gtk_scale_set_draw_value(GTK_SCALE(hscale), TRUE); gtk_range_set_update_policy(GTK_RANGE(hscale), GTK_UPDATE_DISCONTINUOUS); gtk_signal_connect_object(GTK_OBJECT(subsong_adj), "value_changed", GTK_SIGNAL_FUNC(uade_seek_directly), NULL); /* previous subsong button, will be used by all styles of the seek popup*/ prev_button = gtk_button_new_with_label("<"); gtk_widget_set_usize(prev_button, 27, -1); gtk_signal_connect_object(GTK_OBJECT(prev_button), "clicked", GTK_SIGNAL_FUNC(uade_seek_previous), NULL); prev_button_frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(prev_button_frame), GTK_SHADOW_IN); /* next subsong button, will be used by all styles of the seek popup*/ next_button = gtk_button_new_with_label(">"); gtk_widget_set_usize(next_button, 27, -1); gtk_signal_connect_object(GTK_OBJECT(next_button), "clicked", GTK_SIGNAL_FUNC(uade_seek_next), NULL); ffwd_button_frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(ffwd_button_frame), GTK_SHADOW_IN); ffwd_button = gtk_button_new_with_label("10s fwd"); gtk_widget_set_usize(ffwd_button, 27, -1); gtk_signal_connect_object(GTK_OBJECT(ffwd_button), "clicked", GTK_SIGNAL_FUNC(uade_ffwd), NULL); /* with the alternative styles of the subsongseeker, * following suggestions made by David Le Corfec*/ seek_button_box = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(seekpopup), seek_button_box); frame = gtk_frame_new(NULL); gtk_box_pack_start_defaults(GTK_BOX(seek_button_box), frame); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT); seek_button_vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), seek_button_vbox); gtk_signal_connect(GTK_OBJECT(seek_button_vbox), "focus_out_event", GTK_SIGNAL_FUNC(focus_out_event), NULL); prev_next_button_box = gtk_hbox_new(FALSE, 0); /* use the previous defined buttons here */ gtk_box_pack_start_defaults(GTK_BOX(seek_button_vbox), prev_button_frame); gtk_container_add(GTK_CONTAINER(prev_button_frame), prev_next_button_box); gtk_box_pack_start_defaults(GTK_BOX(prev_next_button_box), prev_button); gtk_box_pack_start_defaults(GTK_BOX(prev_next_button_box), next_button); seek_slider_box = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(seek_button_vbox), seek_slider_box, FALSE, FALSE, 0); /* use the previous defined slider and label here */ gtk_box_pack_start(GTK_BOX(seek_slider_box), hscale, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(seek_slider_box), maxsong_label, FALSE, FALSE, 0); /* use the previous defined buttons here */ gtk_box_pack_start_defaults(GTK_BOX(seek_button_vbox), ffwd_button_frame); gtk_container_add(GTK_CONTAINER(ffwd_button_frame), ffwd_button); gtk_widget_show_all(seekpopup); seekpopup_open = 1; } else { gdk_window_raise(seekpopup->window); } }
static void setup_dialog (GtkBuilder * dialog) { gchar *monitor; g_settings_bind (keyboard_settings, "repeat", WID ("repeat_toggle"), "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (keyboard_settings, "repeat", WID ("repeat_table"), "sensitive", G_SETTINGS_BIND_DEFAULT); g_settings_bind (keyboard_settings, "delay", gtk_range_get_adjustment (GTK_RANGE (WID ("repeat_delay_scale"))), "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (keyboard_settings, "rate", gtk_range_get_adjustment (GTK_RANGE (WID ("repeat_speed_scale"))), "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (interface_settings, "cursor-blink", WID ("cursor_toggle"), "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (interface_settings, "cursor-blink", WID ("cursor_hbox"), "sensitive", G_SETTINGS_BIND_DEFAULT); g_settings_bind (interface_settings, "cursor-blink-time", gtk_range_get_adjustment (GTK_RANGE (WID ("cursor_blink_time_scale"))), "value", G_SETTINGS_BIND_DEFAULT); /* Ergonomics */ monitor = g_find_program_in_path ("mate-typing-monitor"); if (monitor != NULL) { g_free (monitor); g_settings_bind (typing_break_settings, "enabled", WID ("break_enabled_toggle"), "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (typing_break_settings, "enabled", WID ("break_details_table"), "sensitive", G_SETTINGS_BIND_DEFAULT); g_settings_bind (typing_break_settings, "type-time", WID ("break_enabled_spin"), "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (typing_break_settings, "break-time", WID ("break_interval_spin"), "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (typing_break_settings, "allow-postpone", WID ("break_postponement_toggle"), "active", G_SETTINGS_BIND_DEFAULT); } else { /* don't show the typing break tab if the daemon is not available */ GtkNotebook *nb = GTK_NOTEBOOK (WID ("keyboard_notebook")); gint tb_page = gtk_notebook_page_num (nb, WID ("break_enabled_toggle")); gtk_notebook_remove_page (nb, tb_page); } #if !GTK_CHECK_VERSION (3, 0, 0) gtk_range_set_update_policy (GTK_RANGE (WID ("cursor_blink_time_scale")), GTK_UPDATE_DISCONTINUOUS); #endif g_signal_connect (WID ("keyboard_dialog"), "response", (GCallback) dialog_response, NULL); setup_xkb_tabs (dialog); setup_a11y_tabs (dialog); }
/*! \todo Finish function documentation!!! * \brief * \par Function Description * */ void x_window_create_main(GschemToplevel *w_current) { TOPLEVEL *toplevel = gschem_toplevel_get_toplevel (w_current); GtkPolicyType policy; GtkWidget *main_box=NULL; GtkWidget *menubar=NULL; GtkWidget *toolbar=NULL; GtkWidget *handlebox=NULL; GtkWidget *hscrollbar; GtkWidget *vscrollbar; GtkAdjustment *hadjustment; GtkAdjustment *vadjustment; char *right_button_text; /* used to signify that the window isn't mapped yet */ w_current->window = NULL; w_current->main_window = GTK_WIDGET (gschem_main_window_new ()); gtk_widget_set_name (w_current->main_window, "gschem"); gtk_window_set_policy (GTK_WINDOW (w_current->main_window), TRUE, TRUE, TRUE); /* We want the widgets to flow around the drawing area, so we don't * set a size of the main window. The drawing area's size is fixed, * see below */ /* * normally we let the window manager handle locating and sizing * the window. However, for some batch processing of schematics * (generating a pdf of all schematics for example) we want to * override this. Hence "auto_place_mode". */ if( auto_place_mode ) gtk_widget_set_uposition (w_current->main_window, 10, 10); /* this should work fine */ g_signal_connect (G_OBJECT (w_current->main_window), "delete_event", G_CALLBACK (i_callback_close_wm), w_current); /* Containers first */ main_box = gtk_vbox_new(FALSE, 1); gtk_container_border_width(GTK_CONTAINER(main_box), 0); gtk_container_add(GTK_CONTAINER(w_current->main_window), main_box); menubar = get_main_menu (w_current); if (w_current->handleboxes) { handlebox = gtk_handle_box_new (); gtk_box_pack_start(GTK_BOX(main_box), handlebox, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (handlebox), menubar); } else { gtk_box_pack_start(GTK_BOX(main_box), menubar, FALSE, FALSE, 0); } w_current->menubar = menubar; gtk_widget_realize (w_current->main_window); if (w_current->handleboxes && w_current->toolbars) { handlebox = gtk_handle_box_new (); gtk_box_pack_start (GTK_BOX (main_box), handlebox, FALSE, FALSE, 0); } if (w_current->toolbars) { toolbar = gtk_toolbar_new(); gtk_toolbar_set_orientation (GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style (GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); if (w_current->handleboxes) { gtk_container_add (GTK_CONTAINER (handlebox), toolbar); } else { gtk_box_pack_start(GTK_BOX(main_box), toolbar, FALSE, FALSE, 0); } gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("New"), _("New file"), "toolbar/new", x_window_stock_pixmap("new", w_current), (GtkSignalFunc) i_callback_toolbar_file_new, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Open"), _("Open file..."), "toolbar/open", x_window_stock_pixmap("open", w_current), (GtkSignalFunc) i_callback_toolbar_file_open, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Save"), _("Save file"), "toolbar/save", x_window_stock_pixmap("save", w_current), (GtkSignalFunc) i_callback_toolbar_file_save, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Undo"), _("Undo last operation"), "toolbar/undo", x_window_stock_pixmap("undo", w_current), (GtkSignalFunc) i_callback_toolbar_edit_undo, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Redo"), _("Redo last undo"), "toolbar/redo", x_window_stock_pixmap("redo", w_current), (GtkSignalFunc) i_callback_toolbar_edit_redo, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); /* not part of any radio button group */ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Component"), _("Add component...\nSelect library and component from list, move the mouse into main window, click to place\nRight mouse button to cancel"), "toolbar/component", x_window_stock_pixmap("insert-symbol", w_current), (GtkSignalFunc) i_callback_toolbar_add_component, w_current); w_current->toolbar_net = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, NULL, _("Nets"), _("Add nets mode\nRight mouse button to cancel"), "toolbar/nets", x_window_stock_pixmap("insert-net", w_current), (GtkSignalFunc) i_callback_toolbar_add_net, w_current); w_current->toolbar_bus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, w_current->toolbar_net, _("Bus"), _("Add buses mode\nRight mouse button to cancel"), "toolbar/bus", x_window_stock_pixmap("insert-bus", w_current), (GtkSignalFunc) i_callback_toolbar_add_bus, w_current); /* not part of any radio button group */ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Text"), _("Add Text..."), "toolbar/text", x_window_stock_pixmap("insert-text", w_current), (GtkSignalFunc) i_callback_toolbar_add_text, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); w_current->toolbar_select = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, w_current->toolbar_bus, _("Select"), _("Select mode"), "toolbar/select", x_window_stock_pixmap("select", w_current), (GtkSignalFunc) i_callback_toolbar_edit_select, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w_current->toolbar_select), TRUE); } /* Try to create popup menu (appears in right mouse button */ w_current->popup_menu = (GtkWidget *) get_main_popup(w_current); /* Setup a GtkScrolledWindow for the drawing area */ hadjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, toplevel->init_right, 100.0, 100.0, 10.0)); vadjustment = GTK_ADJUSTMENT (gtk_adjustment_new (toplevel->init_bottom, 0.0, toplevel->init_bottom, 100.0, 100.0, 10.0)); w_current->scrolled = gtk_scrolled_window_new (hadjustment, vadjustment); gtk_container_add(GTK_CONTAINER(main_box), w_current->scrolled); x_window_create_drawing(w_current->scrolled, w_current); x_window_setup_draw_events(w_current); policy = (w_current->scrollbars_flag) ? GTK_POLICY_ALWAYS : GTK_POLICY_NEVER; gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w_current->scrolled), policy, policy); hscrollbar = gtk_scrolled_window_get_hscrollbar (GTK_SCROLLED_WINDOW (w_current->scrolled)); gtk_range_set_update_policy (GTK_RANGE (hscrollbar), GTK_UPDATE_CONTINUOUS); vscrollbar = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (w_current->scrolled)); gtk_range_set_update_policy (GTK_RANGE (vscrollbar), GTK_UPDATE_CONTINUOUS); /* macro box */ w_current->macro_widget = GTK_WIDGET (g_object_new (GSCHEM_TYPE_MACRO_WIDGET, NULL)); gtk_box_pack_start (GTK_BOX (main_box), w_current->macro_widget, FALSE, FALSE, 0); g_signal_connect (w_current->macro_widget, "response", G_CALLBACK (&x_window_invoke_macro), w_current); /* bottom box */ if (default_third_button == POPUP_ENABLED) { right_button_text = _("Menu/Cancel"); } else { right_button_text = _("Pan/Cancel"); } w_current->bottom_widget = GTK_WIDGET (g_object_new (GSCHEM_TYPE_BOTTOM_WIDGET, "grid-mode", gschem_options_get_grid_mode (w_current->options), "grid-size", gschem_options_get_snap_size (w_current->options), /* x_grid_query_drawn_spacing (w_current), -- occurs before the page is set */ "left-button-text", _("Pick"), "middle-button-text", _("none"), "right-button-text", right_button_text, "snap-mode", gschem_options_get_snap_mode (w_current->options), "snap-size", gschem_options_get_snap_size (w_current->options), "status-text", _("Select Mode"), NULL)); i_update_middle_button (w_current, NULL, NULL); gtk_box_pack_start (GTK_BOX (main_box), w_current->bottom_widget, FALSE, FALSE, 0); gtk_widget_show_all (w_current->main_window); w_current->window = w_current->drawing_area->window; w_current->drawable = w_current->window; x_window_setup_gc(w_current); }
/*! \todo Finish function documentation!!! * \brief * \par Function Description * */ void x_window_create_main(GSCHEM_TOPLEVEL *w_current) { TOPLEVEL *toplevel = w_current->toplevel; GtkWidget *label=NULL; GtkWidget *main_box=NULL; GtkWidget *menubar=NULL; GtkWidget *drawbox=NULL; GtkWidget *bottom_box=NULL; GtkWidget *toolbar=NULL; GtkWidget *handlebox=NULL; /* used to signify that the window isn't mapped yet */ w_current->window = NULL; w_current->main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_name (w_current->main_window, "gschem"); gtk_window_set_policy (GTK_WINDOW (w_current->main_window), TRUE, TRUE, TRUE); /* We want the widgets to flow around the drawing area, so we don't * set a size of the main window. The drawing area's size is fixed, * see below */ /* * normally we let the window manager handle locating and sizing * the window. However, for some batch processing of schematics * (generating a pdf of all schematics for example) we want to * override this. Hence "auto_place_mode". */ if( auto_place_mode ) gtk_widget_set_uposition (w_current->main_window, 10, 10); /* this should work fine */ g_signal_connect (G_OBJECT (w_current->main_window), "delete_event", G_CALLBACK (i_callback_close_wm), w_current); /* Containers first */ main_box = gtk_vbox_new(FALSE, 1); gtk_container_border_width(GTK_CONTAINER(main_box), 0); gtk_container_add(GTK_CONTAINER(w_current->main_window), main_box); menubar = get_main_menu (w_current); if (w_current->handleboxes) { handlebox = gtk_handle_box_new (); gtk_box_pack_start(GTK_BOX(main_box), handlebox, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (handlebox), menubar); } else { gtk_box_pack_start(GTK_BOX(main_box), menubar, FALSE, FALSE, 0); } w_current->menubar = menubar; gtk_widget_realize (w_current->main_window); if (w_current->handleboxes && w_current->toolbars) { handlebox = gtk_handle_box_new (); gtk_box_pack_start (GTK_BOX (main_box), handlebox, FALSE, FALSE, 0); } if (w_current->toolbars) { toolbar = gtk_toolbar_new(); gtk_toolbar_set_orientation (GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style (GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); if (w_current->handleboxes) { gtk_container_add (GTK_CONTAINER (handlebox), toolbar); } else { gtk_box_pack_start(GTK_BOX(main_box), toolbar, FALSE, FALSE, 0); } gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("New"), _("New file"), "toolbar/new", x_window_stock_pixmap("new", w_current), (GtkSignalFunc) i_callback_toolbar_file_new, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Open"), _("Open file..."), "toolbar/open", x_window_stock_pixmap("open", w_current), (GtkSignalFunc) i_callback_toolbar_file_open, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Save"), _("Save file"), "toolbar/save", x_window_stock_pixmap("save", w_current), (GtkSignalFunc) i_callback_toolbar_file_save, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Undo"), _("Undo last operation"), "toolbar/undo", x_window_stock_pixmap("undo", w_current), (GtkSignalFunc) i_callback_toolbar_edit_undo, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Redo"), _("Redo last undo"), "toolbar/redo", x_window_stock_pixmap("redo", w_current), (GtkSignalFunc) i_callback_toolbar_edit_redo, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); /* not part of any radio button group */ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Component"), _("Add component...\nSelect library and component from list, move the mouse into main window, click to place\nRight mouse button to cancel"), "toolbar/component", x_window_stock_pixmap("comp", w_current), (GtkSignalFunc) i_callback_toolbar_add_component, w_current); w_current->toolbar_net = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, NULL, _("Nets"), _("Add nets mode\nRight mouse button to cancel"), "toolbar/nets", x_window_stock_pixmap("net", w_current), (GtkSignalFunc) i_callback_toolbar_add_net, w_current); w_current->toolbar_bus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, w_current->toolbar_net, _("Bus"), _("Add buses mode\nRight mouse button to cancel"), "toolbar/bus", x_window_stock_pixmap("bus", w_current), (GtkSignalFunc) i_callback_toolbar_add_bus, w_current); /* not part of any radio button group */ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Text"), _("Add Text..."), "toolbar/text", x_window_stock_pixmap("text", w_current), (GtkSignalFunc) i_callback_toolbar_add_text, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); w_current->toolbar_select = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, w_current->toolbar_bus, _("Select"), _("Select mode"), "toolbar/select", x_window_stock_pixmap("select", w_current), (GtkSignalFunc) i_callback_toolbar_edit_select, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w_current->toolbar_select), TRUE); } /* Try to create popup menu (appears in right mouse button */ w_current->popup_menu = (GtkWidget *) get_main_popup(w_current); drawbox = gtk_hbox_new(FALSE, 0); gtk_container_border_width(GTK_CONTAINER(drawbox), 0); gtk_container_add(GTK_CONTAINER(main_box), drawbox); x_window_create_drawing(drawbox, w_current); x_window_setup_draw_events(w_current); if (w_current->scrollbars_flag == TRUE) { /* setup scroll bars */ w_current->v_adjustment = GTK_ADJUSTMENT ( gtk_adjustment_new (toplevel->init_bottom, 0.0, toplevel->init_bottom, 100.0, 100.0, 10.0)); w_current->v_scrollbar = gtk_vscrollbar_new (w_current->v_adjustment); gtk_range_set_update_policy (GTK_RANGE (w_current->v_scrollbar), GTK_UPDATE_CONTINUOUS); gtk_box_pack_start (GTK_BOX (drawbox), w_current->v_scrollbar, FALSE, FALSE, 0); g_signal_connect (w_current->v_adjustment, "value_changed", G_CALLBACK (x_event_vschanged), w_current); w_current->h_adjustment = GTK_ADJUSTMENT ( gtk_adjustment_new (0.0, 0.0, toplevel->init_right, 100.0, 100.0, 10.0)); w_current->h_scrollbar = gtk_hscrollbar_new (w_current->h_adjustment); gtk_range_set_update_policy (GTK_RANGE (w_current->h_scrollbar), GTK_UPDATE_CONTINUOUS); gtk_box_pack_start (GTK_BOX (main_box), w_current->h_scrollbar, FALSE, FALSE, 0); g_signal_connect (w_current->h_adjustment, "value_changed", G_CALLBACK (x_event_hschanged), w_current); } /* macro box */ w_current->macro_entry = gtk_entry_new(); g_signal_connect(w_current->macro_entry, "activate", G_CALLBACK(&x_window_invoke_macro), w_current); w_current->macro_box = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(w_current->macro_box), w_current->macro_entry, TRUE, TRUE, 2); gtk_container_border_width(GTK_CONTAINER(w_current->macro_box), 1); gtk_box_pack_start (GTK_BOX (main_box), w_current->macro_box, FALSE, FALSE, 0); /* bottom box */ bottom_box = gtk_hbox_new(FALSE, 0); gtk_container_border_width(GTK_CONTAINER(bottom_box), 1); gtk_box_pack_start (GTK_BOX (main_box), bottom_box, FALSE, FALSE, 0); /* label = gtk_label_new ("Mouse buttons:"); gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 10); */ label = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 2); w_current->left_label = gtk_label_new (_("Pick")); gtk_box_pack_start (GTK_BOX (bottom_box), w_current->left_label, FALSE, FALSE, 0); label = gtk_label_new ("|"); gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 5); if (w_current->middle_button == STROKE) { #ifdef HAVE_LIBSTROKE w_current->middle_label = gtk_label_new (_("Stroke")); #else w_current->middle_label = gtk_label_new (_("none")); #endif } else if (w_current->middle_button == ACTION) { w_current->middle_label = gtk_label_new (_("Action")); } else { w_current->middle_label = gtk_label_new (_("Repeat/none")); } gtk_box_pack_start (GTK_BOX (bottom_box), w_current->middle_label, FALSE, FALSE, 0); label = gtk_label_new ("|"); gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 5); if (default_third_button == POPUP_ENABLED) { w_current->right_label = gtk_label_new (_("Menu/Cancel")); } else { w_current->right_label = gtk_label_new (_("Pan/Cancel")); } gtk_box_pack_start (GTK_BOX (bottom_box), w_current->right_label, FALSE, FALSE, 0); label = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 5); w_current->grid_label = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (bottom_box), w_current->grid_label, FALSE, FALSE, 10); w_current->status_label = gtk_label_new (_("Select Mode")); gtk_box_pack_end (GTK_BOX (bottom_box), w_current->status_label, FALSE, FALSE, 10); gtk_widget_show_all (w_current->main_window); gtk_widget_hide(w_current->macro_box); w_current->window = w_current->drawing_area->window; w_current->drawable = w_current->window; x_window_setup_gc(w_current); }
struct encdata *enc_new(const char *text) { GtkWidget *verbox, *tabbola; GtkWidget *tmpbar, *tmplabel; GtkWidget *tmpbox; GtkWidget *scaled; GtkWidget *ok; /*gchar *text;*/ bool lame = true; struct encdata *enc = NULL; GList *listola = NULL; /* recycling */ /* init area */ enc = (struct encdata *) g_malloc(sizeof(struct encdata)); /* init area end */ if(!(strcmp(text, "Lame"))) { lame = true; lameid = mixer->create_enc(MP3); enc->outchan = mixer->get_enc(lameid); tmplabel = gtk_label_new(_("Configure Lame Encoder")); } else { oggid = mixer->create_enc(OGG); enc->outchan = mixer->get_enc(oggid); tmplabel= gtk_label_new(_("Configure Ogg/Vorbis Encoder")); } enc->outchan->start(); verbox = gtk_vbox_new(FALSE, 12); gtk_box_pack_start(GTK_BOX(verbox), tmplabel, FALSE, FALSE, 0); enc->verbox = verbox; /*tmplabel = GTK_BIN(w)->child; gtk_label_get(GTK_LABEL(tmplabel), &text);*/ /*winenc = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width(GTK_CONTAINER(winenc), 7); gtk_window_set_policy(GTK_WINDOW(winenc), TRUE, TRUE, TRUE); gtk_signal_connect(GTK_OBJECT(winenc), "destroy", (GtkSignalFunc) gtk_widget_destroyed, &winenc);*/ tmpbox = gtk_hbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(verbox), tmpbox, FALSE, FALSE, 0); tmplabel = gtk_label_new(_("Quality: (low)")); gtk_box_pack_start(GTK_BOX(tmpbox), tmplabel, FALSE, FALSE, 0); enc->adj1 = gtk_adjustment_new(0.0, 1.0, 9.0, 1.0, 1.0, 0.0); g_signal_connect(G_OBJECT(enc->adj1), "value_changed", G_CALLBACK(gcb_enc_set_quality), enc); scaled = gtk_hscale_new(GTK_ADJUSTMENT(enc->adj1)); gtk_range_set_update_policy(GTK_RANGE(scaled), GTK_UPDATE_CONTINUOUS); gtk_scale_set_draw_value(GTK_SCALE(scaled), FALSE); gtk_widget_set_size_request(scaled, 100, 30); gtk_box_pack_start(GTK_BOX(tmpbox), scaled, FALSE, FALSE, 0); tmplabel = gtk_label_new(_("(high)")); gtk_box_pack_start(GTK_BOX(tmpbox), tmplabel, FALSE, FALSE, 0); tmplabel = gtk_label_new(_(" Mode")); gtk_box_pack_start(GTK_BOX(tmpbox), tmplabel, FALSE, FALSE, 0); enc->mode = gtk_combo_new(); listola = g_list_append(listola, (void *) _("mono")); listola = g_list_append(listola, (void *) _("stereo")); gtk_combo_set_popdown_strings(GTK_COMBO(enc->mode), listola); gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(enc->mode)->entry), FALSE); g_list_free(listola); listola = NULL; gtk_widget_set_size_request(enc->mode, 70, 22); gtk_box_pack_start(GTK_BOX(tmpbox), enc->mode, FALSE, FALSE, 0); enc->adj_lab = gtk_label_new(""); gtk_box_pack_start(GTK_BOX(verbox), enc->adj_lab, FALSE, FALSE, 0); gtk_adjustment_set_value(GTK_ADJUSTMENT(enc->adj1), 2.0); /* hidden info */ tabbola = gtk_table_new(3, 4, FALSE); gtk_table_set_row_spacings(GTK_TABLE(tabbola), 12); gtk_table_set_col_spacings(GTK_TABLE(tabbola), 12); gtk_box_pack_start(GTK_BOX(verbox), tabbola, FALSE, FALSE, 0); enc->tabbola = tabbola; tmplabel = gtk_label_new(_("bitrate")); gtk_table_attach_defaults(GTK_TABLE(tabbola), tmplabel, 0, 1, 0, 1); enc->bitrate = gtk_combo_new(); listola = g_list_append(listola, (void *) "16"); listola = g_list_append(listola, (void *) "24"); listola = g_list_append(listola, (void *) "32"); listola = g_list_append(listola, (void *) "48"); listola = g_list_append(listola, (void *) "56"); listola = g_list_append(listola, (void *) "64"); listola = g_list_append(listola, (void *) "96"); listola = g_list_append(listola, (void *) "128"); gtk_combo_set_popdown_strings(GTK_COMBO(enc->bitrate), listola); gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(enc->bitrate)->entry), FALSE); g_list_free(listola); listola = NULL; gtk_widget_set_size_request(enc->bitrate, 70, 22); gtk_table_attach_defaults(GTK_TABLE(tabbola), enc->bitrate, 1, 2, 0, 1); tmplabel = gtk_label_new(_("frequency filtering")); gtk_table_attach_defaults(GTK_TABLE(tabbola), tmplabel, 2, 3, 0, 1); enc->freqfil = gtk_combo_new(); listola = g_list_append(listola, (void *) _("auto")); listola = g_list_append(listola, (void *) _("none")); listola = g_list_append(listola, (void *) _("manual")); gtk_combo_set_popdown_strings(GTK_COMBO(enc->freqfil), listola); g_list_free(listola); listola = NULL; g_signal_connect(G_OBJECT(GTK_COMBO(enc->freqfil)->entry), "changed", G_CALLBACK(gcb_set_pass), enc); gtk_widget_set_size_request(enc->freqfil, 70, 22); gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(enc->freqfil)->entry), FALSE); gtk_table_attach_defaults(GTK_TABLE(tabbola), enc->freqfil, 3, 4, 0, 1); tmplabel=gtk_label_new(_("frequency")); gtk_table_attach_defaults(GTK_TABLE(tabbola), tmplabel, 0, 1, 1, 2); enc->freq = gtk_combo_new(); listola = g_list_append(listola, (void *) "auto"); listola = g_list_append(listola, (void *) "11000"); listola = g_list_append(listola, (void *) "16000"); listola = g_list_append(listola, (void *) "22050"); listola = g_list_append(listola, (void *) "44100"); gtk_combo_set_popdown_strings(GTK_COMBO(enc->freq), listola); g_list_free(listola); listola = NULL; gtk_widget_set_size_request(enc->freq, 70, 22); gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(enc->freq)->entry), FALSE); gtk_table_attach_defaults(GTK_TABLE(tabbola), enc->freq, 1, 2, 1, 2); tmplabel = gtk_label_new(_("lowpass Hz")); gtk_table_attach_defaults(GTK_TABLE(tabbola), tmplabel, 2, 3, 1, 2); enc->lowps = gtk_entry_new(); gtk_entry_set_editable(GTK_ENTRY(enc->lowps), FALSE); gtk_entry_set_text(GTK_ENTRY(enc->lowps), _("guessed")); gtk_widget_set_size_request(enc->lowps, 70, 22); gtk_table_attach_defaults(GTK_TABLE(tabbola), enc->lowps, 3, 4, 1, 2); tmplabel = gtk_label_new(_("highpass Hz")); gtk_table_attach_defaults(GTK_TABLE(tabbola), tmplabel, 2, 3, 2, 3); enc->highps = gtk_entry_new(); gtk_entry_set_editable(GTK_ENTRY(enc->highps), FALSE); gtk_entry_set_text(GTK_ENTRY(enc->highps), _("guessed")); gtk_widget_set_size_request(enc->highps, 70, 22); gtk_table_attach_defaults(GTK_TABLE(tabbola), enc->highps, 3, 4, 2, 3); /* end of hidden info */ enc->tasti = gtk_vbox_new(FALSE, 5); enc->expert = gtk_toggle_button_new_with_label(_("I'm Expert...")); g_signal_connect(G_OBJECT(enc->expert), "toggled", G_CALLBACK(expert_mode), tabbola); gtk_box_pack_start(GTK_BOX(enc->tasti), enc->expert, FALSE, FALSE, 0); /* profile menu */ tmpbar = gtk_menu_bar_new(); gtk_box_pack_start(GTK_BOX(enc->tasti), tmpbar, FALSE, FALSE, 0); enc->profroot = gtk_menu_item_new_with_label(_("Profile...")); gtk_menu_bar_append(GTK_MENU_BAR(tmpbar), enc->profroot); if(enc->outchan->tipo == MP3) profile_lame_load(); else profile_vorbis_load(); enc_profmenu(enc); /* profile menu end */ ok = gtk_button_new_with_label(_("Apply")); gtk_button_set_relief(GTK_BUTTON(ok), GTK_RELIEF_HALF); g_signal_connect(G_OBJECT(ok), "clicked", G_CALLBACK(gcb_set_enc), enc); gtk_box_pack_start(GTK_BOX(enc->tasti), ok, FALSE, FALSE, 0); /* set value from core */ enc_put(enc); gtk_widget_show_all(verbox); gtk_widget_hide_on_delete(tabbola); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enc->expert), FALSE); return enc; }
int main(int argc, char **argv) { char *socketname = get_config_name("control"); /* check if japlay is already running */ if (socketname && file_exists(socketname)) { int fd = unix_socket_connect(socketname); if (fd >= 0) { int i; for (i = 1; i < argc; ++i) { char *path = absolute_path(argv[i]); if (path) { sendto(fd, path, strlen(path), 0, NULL, 0); free(path); } } close(fd); return 0; } /* remove leftover socket */ unlink(socketname); } g_thread_init(NULL); gdk_threads_init(); gdk_threads_enter(); gtk_init(&argc, &argv); main_thread = g_thread_self(); if (japlay_init(&argc, argv)) { error("Can not initialize japlay\n"); return -1; } main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(main_window), APP_NAME); g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(destroy_cb), NULL); g_signal_connect(G_OBJECT(main_window), "key-press-event", G_CALLBACK(key_pressed_cb), NULL); GtkWidget *menubar = gtk_menu_bar_new(); GtkWidget *file_menu = gtk_menu_new(); GtkWidget *item = gtk_menu_item_new_with_label("New playlist"); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(new_playlist_cb), NULL); gtk_menu_append(GTK_MENU(file_menu), item); item = gtk_menu_item_new_with_label("Add directory to the playlist..."); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(add_dir_cb), NULL); gtk_menu_append(GTK_MENU(file_menu), item); item = gtk_menu_item_new_with_label("Clear playlist"); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(clear_playlist_cb), NULL); gtk_menu_append(GTK_MENU(file_menu), item); item = gtk_separator_menu_item_new(); gtk_menu_append(GTK_MENU(file_menu), item); item = gtk_check_menu_item_new_with_label("Enable shuffle"); g_signal_connect(G_OBJECT(item), "toggled", G_CALLBACK(enable_shuffle_cb), NULL); gtk_menu_append(GTK_MENU(file_menu), item); item = gtk_check_menu_item_new_with_label("Enable automatic volume"); g_signal_connect(G_OBJECT(item), "toggled", G_CALLBACK(enable_autovol_cb), NULL); gtk_menu_append(GTK_MENU(file_menu), item); /*item = gtk_menu_item_new_with_label("Scan playlist"); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(scan_playlist_cb), NULL); gtk_menu_append(GTK_MENU(file_menu), item);*/ item = gtk_separator_menu_item_new(); gtk_menu_append(GTK_MENU(file_menu), item); item = gtk_menu_item_new_with_label("Quit"); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(destroy_cb), NULL); gtk_menu_append(GTK_MENU(file_menu), item); item = gtk_menu_item_new_with_label("File"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), file_menu); gtk_menu_bar_append(GTK_MENU_BAR(menubar), item); static const struct button { const char *stockid; const char *help; void (*const cb)(GtkButton *button, gpointer ptr); } buttons[] = { {GTK_STOCK_MEDIA_PLAY, "Play", play_cb}, {GTK_STOCK_MEDIA_STOP, "stop", stop_cb}, {GTK_STOCK_MEDIA_PAUSE, "Pause", pause_cb}, {GTK_STOCK_MEDIA_NEXT, "Skip to the next song in the queue", next_cb}, {GTK_STOCK_OPEN, "Add files to the playlist", add_cb}, {GTK_STOCK_OK, "Add selected songs to the queue", enqueue_cb}, {GTK_STOCK_DELETE, "Remove selected songs", remove_cb}, {NULL, NULL, NULL} }; GtkWidget *toolbar = gtk_hbox_new(false, 0); int i; for (i = 0; buttons[i].stockid; ++i) { GtkWidget *button = gtk_button_new(); GtkWidget *image = gtk_image_new_from_stock(buttons[i].stockid, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_button_set_image(GTK_BUTTON(button), image); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(buttons[i].cb), NULL); gtk_box_pack_start(GTK_BOX(toolbar), button, false, true, 0); gtk_widget_set_tooltip_text(button, buttons[i].help); } scope_area = gtk_drawing_area_new(); gtk_widget_set_size_request(scope_area, SCOPE_WIDTH, -1); gtk_box_pack_start(GTK_BOX(toolbar), scope_area, false, true, 0); g_signal_connect(G_OBJECT(scope_area), "expose_event", G_CALLBACK(expose_event_cb), NULL); seekbar = gtk_hscale_new_with_range(0, 1, 1); gtk_range_set_update_policy(GTK_RANGE(seekbar), GTK_UPDATE_DELAYED); g_signal_connect(G_OBJECT(seekbar), "change-value", G_CALLBACK(seek_cb), NULL); g_signal_connect(G_OBJECT(seekbar), "format-value", G_CALLBACK(format_seek_cb), NULL); notebook = gtk_notebook_new(); GtkWidget *vbox = gtk_vbox_new(false, 0); gtk_box_pack_start(GTK_BOX(vbox), menubar, false, true, 0); gtk_box_pack_start(GTK_BOX(vbox), toolbar, false, true, 0); gtk_box_pack_start(GTK_BOX(vbox), seekbar, false, true, 0); gtk_box_pack_start(GTK_BOX(vbox), notebook, true, true, 0); gtk_container_add(GTK_CONTAINER(main_window), vbox); gtk_widget_show_all(main_window); /* TODO: load all playlists */ main_playlist = new_playlist(); add_playlist_page(main_playlist, "Main"); add_playlist_page(japlay_queue, "Play queue"); add_playlist_page(japlay_history, "History"); char *playlistpath = get_config_name("main_playlist.m3u"); if (playlistpath) load_playlist(main_playlist, playlistpath); char *queuepath = get_config_name("queue.m3u"); if (queuepath) load_playlist(japlay_queue, queuepath); char *settingspath = get_config_name("settings.cfg"); if (settingspath) load_settings(settingspath); for (i = 1; i < argc; ++i) add_file_playlist(main_playlist, argv[i]); signal(SIGINT, handle_sigint); int fd = -1; if (socketname) { fd = unix_socket_create(socketname); if (fd >= 0) { GIOChannel *io = g_io_channel_unix_new(fd); g_io_add_watch(io, G_IO_IN, incoming_client, NULL); } } gtk_main(); if (fd >= 0) unlink(socketname); if (playlistpath) save_playlist_m3u(main_playlist, playlistpath); if (queuepath) save_playlist_m3u(japlay_queue, queuepath); if (settingspath) save_settings(settingspath); japlay_exit(); return 0; }
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); }
CVoxelView::CVoxelView(CVoxelDisplay& rVoxelDisplay) : m_rVoxelDisplay(rVoxelDisplay), m_pBuilderInterface(NULL), m_pCubeButton(NULL), m_pSphereButton(NULL), m_pMinScaleFactorSpinButton(NULL), m_pMaxScaleFactorSpinButton(NULL), m_f64MinScaleFactor(1), m_f64MaxScaleFactor(2), m_pThresholdRangeAndOrLabel(NULL), m_pMinDisplayThresholdBoundaryButton(NULL), m_pMaxDisplayThresholdBoundaryButton(NULL), m_pMinDisplayThresholdScale(NULL), m_pMaxDisplayThresholdScale(NULL), m_f64MinDisplayThreshold(0.25), m_f64MaxDisplayThreshold(0.75) { //load the gtk builder interface m_pBuilderInterface=gtk_builder_new(); // glade_xml_new(OpenViBE::Directories::getDataDir() + "/openvibe-plugins/simple-visualisation/openvibe-simple-visualisation-VoxelDisplay.ui", NULL, NULL); gtk_builder_add_from_file(m_pBuilderInterface, OpenViBE::Directories::getDataDir() + "/openvibe-plugins/simple-visualisation/openvibe-simple-visualisation-VoxelDisplay.ui", NULL); if(!m_pBuilderInterface) { g_warning("Couldn't load the interface!"); return; } gtk_builder_connect_signals(m_pBuilderInterface, NULL); //toolbar //------- //voxel object buttons m_pCubeButton = GTK_RADIO_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "CubeButton")); m_pSphereButton = GTK_RADIO_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "SphereButton")); g_signal_connect(G_OBJECT(m_pCubeButton), "toggled", G_CALLBACK(setVoxelObjectCallback), this); g_signal_connect(G_OBJECT(m_pSphereButton), "toggled", G_CALLBACK(setVoxelObjectCallback), this); g_signal_connect(G_OBJECT(gtk_builder_get_object(m_pBuilderInterface, "ModifyColorToolButton")), "toggled", G_CALLBACK(toggleColorModificationCallback), this); g_signal_connect(G_OBJECT(gtk_builder_get_object(m_pBuilderInterface, "ModifyTransparencyToolButton")), "toggled", G_CALLBACK(toggleTransparencyModificationCallback), this); g_signal_connect(G_OBJECT(gtk_builder_get_object(m_pBuilderInterface, "ModifySizeToolButton")), "toggled", G_CALLBACK(toggleSizeModificationCallback), this); //min voxel scale factor m_pMinScaleFactorSpinButton = GTK_SPIN_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "MinScaleFactorSpinButton")); m_rVoxelDisplay.setMinScaleFactor(m_f64MinScaleFactor); gtk_spin_button_configure( m_pMinScaleFactorSpinButton, GTK_ADJUSTMENT(gtk_adjustment_new( m_f64MinScaleFactor, //initial value 0, //lower 5, //upper 0.1, //step increment 0.5, //page increment 0)), //page size - deprecated 0.1, //climb rate 1); //digits g_signal_connect(G_OBJECT(m_pMinScaleFactorSpinButton), "value-changed", G_CALLBACK(setMinScaleFactorCallback), this); //max voxel scale factor m_pMaxScaleFactorSpinButton = GTK_SPIN_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "MaxScaleFactorSpinButton")); m_rVoxelDisplay.setMaxScaleFactor(m_f64MaxScaleFactor); gtk_spin_button_configure( m_pMaxScaleFactorSpinButton, GTK_ADJUSTMENT(gtk_adjustment_new( m_f64MaxScaleFactor, //initial value 0, //lower 5, //upper 0.1, //step increment 0.5, //page increment 0)), //page size - deprecated 0.1, //climb rate 1); //digits g_signal_connect(G_OBJECT(m_pMaxScaleFactorSpinButton), "value-changed", G_CALLBACK(setMaxScaleFactorCallback), this); boolean l_bInclusiveDisplayThresholdBoundary = true; m_rVoxelDisplay.setDisplayThresholdBoundaryType(l_bInclusiveDisplayThresholdBoundary); //AND/OR label m_pThresholdRangeAndOrLabel = GTK_LABEL(gtk_builder_get_object(m_pBuilderInterface, "ThresholdRangeAndOrLabel")); gtk_label_set_label(m_pThresholdRangeAndOrLabel, l_bInclusiveDisplayThresholdBoundary? "AND" : "OR"); //min display threshold boundary type m_pMinDisplayThresholdBoundaryButton = GTK_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "MinDisplayThresholdBoundaryButton")); gtk_button_set_label(m_pMinDisplayThresholdBoundaryButton, l_bInclusiveDisplayThresholdBoundary ? ">" : "<"); g_signal_connect(G_OBJECT(m_pMinDisplayThresholdBoundaryButton), "clicked", G_CALLBACK(setMinDisplayThresholdBoundaryTypeCallback), this); //max display threshold boundary type m_pMaxDisplayThresholdBoundaryButton = GTK_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "MaxDisplayThresholdBoundaryButton")); gtk_button_set_label(m_pMaxDisplayThresholdBoundaryButton, l_bInclusiveDisplayThresholdBoundary ? "<" : ">"); g_signal_connect(G_OBJECT(m_pMaxDisplayThresholdBoundaryButton), "clicked", G_CALLBACK(setMaxDisplayThresholdBoundaryTypeCallback), this); //min display threshold slider m_pMinDisplayThresholdScale = GTK_SCALE(gtk_hscale_new_with_range(0.0, 1.0, 0.01)); m_rVoxelDisplay.setMinDisplayThreshold(m_f64MinDisplayThreshold); gtk_range_set_value(GTK_RANGE(m_pMinDisplayThresholdScale), m_f64MinDisplayThreshold); gtk_scale_set_value_pos(m_pMinDisplayThresholdScale, GTK_POS_TOP); gtk_range_set_update_policy(GTK_RANGE(m_pMinDisplayThresholdScale), GTK_UPDATE_CONTINUOUS); gtk_widget_set_size_request(GTK_WIDGET(m_pMinDisplayThresholdScale), 100, -1); gtk_widget_show_all(GTK_WIDGET(m_pMinDisplayThresholdScale)); g_signal_connect(G_OBJECT(m_pMinDisplayThresholdScale), "value_changed", G_CALLBACK(setMinDisplayThresholdCallback), this); //replace existing scale (which somehow can't be used) with the newly created one GtkWidget* l_pOldMinScale = GTK_WIDGET(gtk_builder_get_object(m_pBuilderInterface, "MinDisplayThresholdScale")); GtkWidget* l_pMinScaleParent = gtk_widget_get_parent(l_pOldMinScale); if(l_pMinScaleParent != NULL && GTK_IS_CONTAINER(l_pMinScaleParent)) { gtk_container_remove(GTK_CONTAINER(l_pMinScaleParent), l_pOldMinScale); if(GTK_IS_BOX(l_pMinScaleParent)) { gtk_box_pack_start(GTK_BOX(l_pMinScaleParent), GTK_WIDGET(m_pMinDisplayThresholdScale), TRUE, TRUE, 0); gtk_box_reorder_child(GTK_BOX(l_pMinScaleParent), GTK_WIDGET(m_pMinDisplayThresholdScale), 1); } } //max display threshold slider m_pMaxDisplayThresholdScale = GTK_SCALE(gtk_hscale_new_with_range(0.0, 1.0, 0.01)); m_rVoxelDisplay.setMaxDisplayThreshold(m_f64MaxDisplayThreshold); gtk_range_set_value(GTK_RANGE(m_pMaxDisplayThresholdScale), m_f64MaxDisplayThreshold); gtk_scale_set_value_pos(m_pMaxDisplayThresholdScale, GTK_POS_TOP); gtk_range_set_update_policy(GTK_RANGE(m_pMaxDisplayThresholdScale), GTK_UPDATE_CONTINUOUS); gtk_widget_set_size_request(GTK_WIDGET(m_pMaxDisplayThresholdScale), 100, -1); gtk_widget_show_all(GTK_WIDGET(m_pMaxDisplayThresholdScale)); g_signal_connect(G_OBJECT(m_pMaxDisplayThresholdScale), "value_changed", G_CALLBACK(setMaxDisplayThresholdCallback), this); //replace existing scale (which somehow can't be used) with the newly created one GtkWidget* l_pOldMaxScale = GTK_WIDGET(gtk_builder_get_object(m_pBuilderInterface, "MaxDisplayThresholdScale")); GtkWidget* l_pMaxScaleParent = gtk_widget_get_parent(l_pOldMaxScale); if(l_pMaxScaleParent != NULL && GTK_IS_CONTAINER(l_pMaxScaleParent)) { gtk_container_remove(GTK_CONTAINER(l_pMaxScaleParent), l_pOldMaxScale); if(GTK_IS_BOX(l_pMaxScaleParent)) { gtk_box_pack_start(GTK_BOX(l_pMaxScaleParent), GTK_WIDGET(m_pMaxDisplayThresholdScale), TRUE, TRUE, 0); gtk_box_reorder_child(GTK_BOX(l_pMaxScaleParent), GTK_WIDGET(m_pMaxDisplayThresholdScale), 1); } } //skull opacity slider GtkWidget* l_pSkullOpacityScale = gtk_hscale_new_with_range(0.0, 1.0, 0.05); float64 l_f64SkullOpacity = 0.07; gtk_range_set_value(GTK_RANGE(l_pSkullOpacityScale), l_f64SkullOpacity); m_rVoxelDisplay.setSkullOpacity(l_f64SkullOpacity); gtk_scale_set_value_pos(GTK_SCALE(l_pSkullOpacityScale), GTK_POS_TOP); gtk_range_set_update_policy(GTK_RANGE(l_pSkullOpacityScale), GTK_UPDATE_CONTINUOUS); gtk_widget_set_size_request(l_pSkullOpacityScale, 100, -1); gtk_widget_show_all(l_pSkullOpacityScale); g_signal_connect(G_OBJECT(l_pSkullOpacityScale), "value_changed", G_CALLBACK(setSkullOpacityCallback), this); //replace existing scale (which somehow can't be used) with the newly created one GtkWidget* l_pOldScale = GTK_WIDGET(gtk_builder_get_object(m_pBuilderInterface, "SkullOpacityScale")); GtkWidget* l_pScaleParent = gtk_widget_get_parent(l_pOldScale); if(l_pScaleParent != NULL && GTK_IS_CONTAINER(l_pScaleParent)) { gtk_container_remove(GTK_CONTAINER(l_pScaleParent), l_pOldScale); if(GTK_IS_BOX(l_pScaleParent)) { gtk_box_pack_start(GTK_BOX(l_pScaleParent), l_pSkullOpacityScale, TRUE, TRUE, 0); gtk_box_reorder_child(GTK_BOX(l_pScaleParent), l_pSkullOpacityScale, 0); } } //camera animation button GtkToggleToolButton* l_pAnimateCameraButton = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "AnimateCameraButton")); g_signal_connect(G_OBJECT(l_pAnimateCameraButton), "toggled", G_CALLBACK(toggleAnimateCameraCallback), this); //reposition camera g_signal_connect(G_OBJECT(gtk_builder_get_object(m_pBuilderInterface, "RepositionCamera")), "clicked", G_CALLBACK(repositionCameraCallback), this); this->toggleColorModificationCB(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "ModifyColorToolButton")))?true:false); this->toggleTransparencyModificationCB(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "ModifyTransparencyToolButton")))?true:false); this->toggleSizeModificationCB(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "ModifySizeToolButton")))?true:false); this->enableAutoCameraMovementCB(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "AnimateCameraButton")))?true:false); }