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