void add_item (gchar *label, gpointer data) { GtkWidget *curve = lookup_widget(app,"curve"); GtkWidget *clist = lookup_widget(app,"clist"); list_entry_t *le; gint row; gchar *labels[2]; if (label==NULL) return; le = g_new (list_entry_t,1); le->minx = gtk_spin_button_get_value_as_float (lookup_widget(app,"minx")); le->maxx = gtk_spin_button_get_value_as_float (lookup_widget(app,"maxx")); le->miny = gtk_spin_button_get_value_as_float (lookup_widget(app,"miny")); le->maxy = gtk_spin_button_get_value_as_float (lookup_widget(app,"maxy")); le->count = gtk_spin_button_get_value_as_int (lookup_widget(app,"count")); le->type = gtk_entry_get_text (lookup_widget(app,"typeentry")); le->name = g_strdup(label); labels[0] = "A+"; labels[1] = le->name; row = gtk_clist_append (clist,labels); gtk_clist_set_row_data (clist,row,le); }
// make the shift increments match the grid settings // the objective being that the shift+arrows shortcuts move the texture by the corresponding grid size // this depends on the current texture scale used? // we move the textures in pixels, not world units. (i.e. increment values are in pixel) // depending on the texture scale it doesn't take the same amount of pixels to move of g_qeglobals.d_gridsize // increment * scale = gridsize static void OnBtnMatchGrid( GtkWidget *widget, gpointer data ){ float hscale, vscale; hscale = gtk_spin_button_get_value_as_float( GTK_SPIN_BUTTON( g_dlgSurface.GetDlgWidget( "hscale" ) ) ); vscale = gtk_spin_button_get_value_as_float( GTK_SPIN_BUTTON( g_dlgSurface.GetDlgWidget( "vscale" ) ) ); if ( hscale == 0.0f || vscale == 0.0f ) { Sys_Printf( "ERROR: unexpected scale == 0.0f\n" ); return; } DoSnapTToGrid( hscale, vscale ); }
void on_maxy_changed (GtkEditable *editable, gpointer user_data) { GtkWidget *curve = lookup_widget(app,"curve"); gfloat minx, maxx, miny, maxy; minx = gtk_spin_button_get_value_as_float (lookup_widget(app,"minx")); maxx = gtk_spin_button_get_value_as_float (lookup_widget(app,"maxx")); miny = gtk_spin_button_get_value_as_float (lookup_widget(app,"miny")); maxy = gtk_spin_button_get_value_as_float (lookup_widget(app,"maxy")); gtk_curve_set_range (curve,minx,maxx,miny,maxy); }
static void on_video_sync_changed(GtkWidget *widget, gpointer data) { startVideoAfter = gtk_spin_button_get_value_as_float((GtkSpinButton *)spinButton); calcCurrentPlayingTime(); sendCurrentPlayingTime(); }
static ObjectChange * bezierline_apply_properties(Bezierline *bezierline) { ObjectState *old_state; if (bezierline != bezierline_properties_dialog->bezierline) { g_message("Bezierline dialog problem: %p != %p", bezierline, bezierline_properties_dialog->bezierline); bezierline = bezierline_properties_dialog->bezierline; } old_state = (ObjectState *)bezierline_get_state(bezierline); bezierline->line_width = gtk_spin_button_get_value_as_float(bezierline_properties_dialog->line_width); dia_color_selector_get_color(bezierline_properties_dialog->color, &bezierline->line_color); dia_line_style_selector_get_linestyle(bezierline_properties_dialog->line_style, &bezierline->line_style, &bezierline->dashlength); bezierline->start_arrow = dia_arrow_selector_get_arrow(bezierline_properties_dialog->start_arrow); bezierline->end_arrow = dia_arrow_selector_get_arrow(bezierline_properties_dialog->end_arrow); bezierline_update_data(bezierline); return new_object_state_change((Object *)bezierline, old_state, (GetStateFunc)bezierline_get_state, (SetStateFunc)bezierline_set_state); }
static ObjectChange * line_apply_properties(Line *line) { ObjectState *old_state; if (line != line_properties_dialog->line) { printf("Dialog problem: %p != %p\n", line, line_properties_dialog->line); line = line_properties_dialog->line; } old_state = (ObjectState *)line_get_state(line); line->line_width = gtk_spin_button_get_value_as_float(line_properties_dialog->line_width); dia_color_selector_get_color(line_properties_dialog->color, &line->line_color); dia_line_style_selector_get_linestyle(line_properties_dialog->line_style, &line->line_style, &line->dashlength); line->start_arrow = dia_arrow_selector_get_arrow(line_properties_dialog->start_arrow); line->end_arrow = dia_arrow_selector_get_arrow(line_properties_dialog->end_arrow); line_update_data(line); return new_object_state_change((Object *)line, old_state, (GetStateFunc)line_get_state, (SetStateFunc)line_set_state); }
static void apply_config(void) { int i; char *field = NULL; free_stations(); nstations = gui_station_count; stations = malloc(sizeof(struct station) * nstations); for (i = 0; i < nstations; i++) { gtk_clist_get_text(GTK_CLIST(gui_station_list), i, 0, &field); stations[i].station_name = strdup(field); gtk_clist_get_text(GTK_CLIST(gui_station_list), i, 1, &field); stations[i].freq = atof(field); } mutetime = gtk_spin_button_get_value_as_float(GTK_SPIN_BUTTON(gui_mutetime_entry)); set_text_freq(radio_getfreq()); /* reset the frequency display */ attempt_reopen = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gui_reopen_toggle)); close_atexit = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gui_close_toggle)); /* recreate the frequency menu */ create_freq_menu(); }
void close_and_add_station_editor(gpointer *userdata) { gint new_entry = (gint)userdata; gchar *f[3]; gfloat freq; gchar fstr[32]; f[0] = (gchar *) gtk_entry_get_text(GTK_ENTRY(gui_station_name_input)); freq = gtk_spin_button_get_value_as_float(GTK_SPIN_BUTTON(gui_freq_input)); sprintf(fstr, "%.2f", freq); f[1] = fstr; f[2] = ""; if (new_entry) { gtk_clist_append(GTK_CLIST(gui_station_list), f); gui_station_count++; } else { assert(gui_station_selected != -1); gtk_clist_set_text(GTK_CLIST(gui_station_list), gui_station_selected, 0, f[0]); gtk_clist_set_text(GTK_CLIST(gui_station_list), gui_station_selected, 1, f[1]); } close_station_editor(); }
static void datasource_gc_get_cmd_string ( datasource_gc_widgets_t *widgets, gchar **cmd, gchar **input_file_type ) { //gchar *safe_string = g_shell_quote ( gtk_entry_get_text ( GTK_ENTRY(widgets->center_entry) ) ); gchar *safe_user = g_shell_quote ( a_preferences_get ( VIKING_GC_PARAMS_NAMESPACE "username")->s ); gchar *safe_pass = g_shell_quote ( a_preferences_get ( VIKING_GC_PARAMS_NAMESPACE "password")->s ); gdouble lat, lon; if ( 2 != sscanf ( gtk_entry_get_text ( GTK_ENTRY(widgets->center_entry) ), "%lf,%lf", &lat, &lon ) ) { g_warning (_("Broken input - using some defaults")); lat = a_vik_get_default_lat(); lon = a_vik_get_default_long(); } // Unix specific shell commands // 1. Remove geocache webpages (maybe be from different location) // 2, Gets upto n geocaches as webpages for the specified user in radius r Miles // 3. Converts webpages into a single waypoint file, ignoring zero location waypoints '-z' // Probably as they are premium member only geocaches and user is only a basic member // Final output is piped into GPSbabel - hence removal of *html is done at beginning of the command sequence *cmd = g_strdup_printf( "rm -f ~/.geo/caches/*html ; %s -P -n%d -r%.1fM -u %s -p %s %.4f %.4f ; %s -z ~/.geo/caches/*html ", GC_PROGRAM1, gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(widgets->num_spin) ), gtk_spin_button_get_value_as_float ( GTK_SPIN_BUTTON(widgets->miles_radius_spin) ), safe_user, safe_pass, lat, lon, GC_PROGRAM2 ); *input_file_type = NULL; //g_free ( safe_string ); g_free ( safe_user ); g_free ( safe_pass ); }
static void on_video_time_tag_changed(GtkWidget *widget, gpointer data) { timeTagInVideo = gtk_spin_button_get_value_as_float((GtkSpinButton *)spinButtonVideo); calcCurrentPlayingTime(); sendCurrentPlayingTime(); }
gfloat GetSpinButtonValue(const gchar *spin_button_name) { GtkWidget *spin_button; spin_button = glade_xml_get_widget(g_cngplp_xml, spin_button_name); if(spin_button == NULL){ return -1; } return gtk_spin_button_get_value_as_float(GTK_SPIN_BUTTON(spin_button)); }
static void datasource_gc_draw_circle ( datasource_gc_widgets_t *widgets ) { gdouble lat, lon; if ( widgets->circle_onscreen ) { vik_viewport_draw_arc ( widgets->vvp, widgets->circle_gc, FALSE, widgets->circle_x - widgets->circle_width/2, widgets->circle_y - widgets->circle_width/2, widgets->circle_width, widgets->circle_width, 0, 360*64 ); } /* calculate widgets circle_x and circle_y */ /* split up lat,lon into lat and lon */ if ( 2 == sscanf ( gtk_entry_get_text ( GTK_ENTRY(widgets->center_entry) ), "%lf,%lf", &lat, &lon ) ) { struct LatLon ll; VikCoord c; gint x, y; ll.lat = lat; ll.lon = lon; vik_coord_load_from_latlon ( &c, vik_viewport_get_coord_mode ( widgets->vvp ), &ll ); vik_viewport_coord_to_screen ( widgets->vvp, &c, &x, &y ); /* TODO: real calculation */ if ( x > -1000 && y > -1000 && x < (vik_viewport_get_width(widgets->vvp) + 1000) && y < (vik_viewport_get_width(widgets->vvp) + 1000) ) { VikCoord c1, c2; gdouble pixels_per_meter; widgets->circle_x = x; widgets->circle_y = y; /* determine miles per pixel */ vik_viewport_screen_to_coord ( widgets->vvp, 0, vik_viewport_get_height(widgets->vvp)/2, &c1 ); vik_viewport_screen_to_coord ( widgets->vvp, vik_viewport_get_width(widgets->vvp), vik_viewport_get_height(widgets->vvp)/2, &c2 ); pixels_per_meter = ((gdouble)vik_viewport_get_width(widgets->vvp)) / vik_coord_diff(&c1, &c2); /* this is approximate */ widgets->circle_width = gtk_spin_button_get_value_as_float ( GTK_SPIN_BUTTON(widgets->miles_radius_spin) ) * METERSPERMILE * pixels_per_meter * 2; vik_viewport_draw_arc ( widgets->vvp, widgets->circle_gc, FALSE, widgets->circle_x - widgets->circle_width/2, widgets->circle_y - widgets->circle_width/2, widgets->circle_width, widgets->circle_width, 0, 360*64 ); widgets->circle_onscreen = TRUE; } else widgets->circle_onscreen = FALSE; } /* see if onscreen */ /* okay */ vik_viewport_sync ( widgets->vvp ); }
void on_buysell_propertybox_apply (GnomePropertyBox *property_box, gint page_num) { struct buysell_data *data=(struct buysell_data *)bs_global_ci->instance_data; if (page_num != -1) return; gnome_color_picker_get_i8(bs_cpick,&data->r,&data->g,&data->b,&data->a); data->price=gtk_spin_button_get_value_as_float(bs_pricespin); data->amount=gtk_spin_button_get_value_as_float(bs_numstocks); data->time=gnome_date_edit_get_date(bs_date); if (GTK_TOGGLE_BUTTON(bs_buybotton)->active) { data->buy=TRUE; } else { data->buy=FALSE; } gtk_object_destroy(GTK_OBJECT(bs_global_ci->fixed_group)); bs_update_xml_node(bs_global_ci); create_buysell(bs_global_ci); if (data->buy) sprintf(data->i_name,"Buy (%.2f @ %.2f)",data->amount,data->price); else sprintf(data->i_name,"Sell (%.2f @ %.2f)",data->amount,data->price); bs_global_ci->instance_name=data->i_name; }
void get_value( GtkWidget *widget, gpointer data ) { gchar buf[32]; GtkLabel *label; GtkSpinButton *spin; spin = GTK_SPIN_BUTTON (spinner1); label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget))); if (GPOINTER_TO_INT (data) == 1) sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin)); else sprintf (buf, "%0.*f", spin->digits, gtk_spin_button_get_value_as_float (spin)); gtk_label_set_text (label, buf); }
static void on_TextEncoderDialog_response (GtkDialog *dialog, gint response_id, gpointer user_data) { GtkWidget *wid; CTextProfile *ret_profile = NULL; if (GTK_RESPONSE_OK == response_id) { CTextProfile *tp = (CTextProfile *)user_data; if (tp == NULL) { wid = lookup_widget(GTK_WIDGET(dialog), "TextProfileEntry"); const char *name = gtk_entry_get_text(GTK_ENTRY(wid)); if (name == NULL || *name == '\0') { ShowMessage("Error", "Must enter profile name"); return; } if (AVFlow->m_text_profile_list->FindProfile(name) != NULL) { ShowMessage("Error", "Profile already exists"); return; } if (AVFlow->m_text_profile_list->CreateConfig(name) == false) { ShowMessage("Error", "profile creation error"); return; } tp = AVFlow->m_text_profile_list->FindProfile(name); ret_profile = tp; } wid = lookup_widget(GTK_WIDGET(dialog), "TextEncodingOptionMenu"); tp->SetStringValue(CFG_TEXT_ENCODING, text_encoder_table[gtk_option_menu_get_history(GTK_OPTION_MENU(wid))].text_encoding); wid = lookup_widget(GTK_WIDGET(dialog), "TextRepeatTimeSpinner"); tp->SetFloatValue(CFG_TEXT_REPEAT_TIME_SECS, gtk_spin_button_get_value_as_float(GTK_SPIN_BUTTON(wid))); tp->Update(); } free(encoderNames); OnTextProfileFinished(ret_profile); gtk_widget_destroy(GTK_WIDGET(dialog)); }
static ObjectChange * arc_apply_properties(Arc *arc) { ObjectState *old_state; old_state = (ObjectState *)arc_get_state(arc); arc->line_width = gtk_spin_button_get_value_as_float(arc_properties_dialog->line_width); dia_color_selector_get_color(arc_properties_dialog->color, &arc->arc_color); dia_line_style_selector_get_linestyle(arc_properties_dialog->line_style, &arc->line_style, &arc->dashlength); arc->start_arrow = dia_arrow_selector_get_arrow(arc_properties_dialog->start_arrow); arc->end_arrow = dia_arrow_selector_get_arrow(arc_properties_dialog->end_arrow); arc_update_data(arc); return new_object_state_change((Object *)arc, old_state, (GetStateFunc)arc_get_state, (SetStateFunc)arc_set_state); }
static ObjectChange * image_apply_properties(Image *image) { gchar *new_file; ObjectState *old_state; if (image != image_properties_dialog->image) { message_warning("Image dialog problem: %p != %p\n", image, image_properties_dialog->image); image = image_properties_dialog->image; } old_state = (ObjectState *)image_get_state(image); image->border_width = gtk_spin_button_get_value_as_float(image_properties_dialog->border_width); dia_color_selector_get_color(image_properties_dialog->fg_color, &image->border_color); dia_line_style_selector_get_linestyle(image_properties_dialog->line_style, &image->line_style, NULL); image->draw_border = gtk_toggle_button_get_active(image_properties_dialog->draw_border); image->keep_aspect = gtk_toggle_button_get_active(image_properties_dialog->keep_aspect); new_file = dia_file_selector_get_file(image_properties_dialog->file); if (image->file) g_free(image->file); if (image->image) { dia_image_release(image->image); } image->image = dia_image_load(new_file); if ((image->image != NULL) && (image->keep_aspect)) { /* Must... keep... aspect... ratio... */ float ratio = (float)dia_image_height(image->image)/ (float)dia_image_width(image->image); image->element.height = image->element.width * ratio; } image->file = g_strdup(new_file); image_update_data(image); return new_object_state_change((Object *)image, old_state, (GetStateFunc)image_get_state, (SetStateFunc)image_set_state); }
void curve_save (gchar *filename, long int seekpos) { GtkWidget *curve = lookup_widget(app,"curve"); guint count, i; gfloat *vector; gchar *type; FILE *out; gfloat minx, maxx, miny, maxy; gfloat scale, f; guint base; minx = gtk_spin_button_get_value_as_float (lookup_widget(app,"minx")); maxx = gtk_spin_button_get_value_as_float (lookup_widget(app,"maxx")); miny = gtk_spin_button_get_value_as_float (lookup_widget(app,"miny")); maxy = gtk_spin_button_get_value_as_float (lookup_widget(app,"maxy")); scale = gtk_spin_button_get_value_as_float (lookup_widget(app,"scale")); base = gtk_spin_button_get_value_as_int (lookup_widget(app,"base")); count = gtk_spin_button_get_value_as_int (lookup_widget(app,"count")); type = gtk_entry_get_text (lookup_widget(app,"typeentry")); vector = g_new (gfloat,count); gtk_curve_get_vector (curve,count,vector); out = fopen(filename, "wb"); if (out == NULL) return; if (seekpos) fseek (out,seekpos,0); if (strcmp(type,"u_char")==0) { u_char val; f = (gfloat)(scale) / (maxy - miny); for (i=0; i<count; i++) { val = base + (u_char) (vector[i] * f); fwrite(&val,sizeof(val),1,out); } } if (strcmp(type,"char")==0) { char val; f = (gfloat)(scale) / (maxy - miny); for (i=0; i<count; i++) { val = (char) (vector[i] * f); fwrite(&val,sizeof(val),1,out); } } if (strcmp(type,"u_short")==0) { u_short val; f = (gfloat)(scale) / (maxy - miny); for (i=0; i<count; i++) { val = (u_short) (vector[i] * f); fwrite(&val,sizeof(val),1,out); } } if (strcmp(type,"short")==0) { short val; f = (gfloat)(scale) / (maxy - miny); printf ("factor=%f scale=%f (%f)\n",f,scale,maxy-miny); for (i=0; i<count; i++) { val = (short) (vector[i] * f); fwrite(&val,sizeof(val),1,out); } } if (strcmp(type,"u_long")==0) { u_long val; f = (gfloat)(scale) / (maxy - miny); for (i=0; i<count; i++) { val = (u_long) (vector[i] * f); fwrite(&val,sizeof(val),1,out); } } if (strcmp(type,"long")==0) { long val; f = (gfloat)(scale) / (maxy - miny); for (i=0; i<count; i++) { val = (long) (vector[i] * f); fwrite(&val,sizeof(val),1,out); } } if (strcmp(type,"float")==0) { fwrite(vector,sizeof(gfloat),count,out); } if (strcmp(type,"double")==0) { gdouble val; for (i=0; i<count; i++) { val = (gdouble) vector[i]; fwrite(&val,sizeof(val),1,out); } } if (strcmp(type,"fixed (4+12)")==0) { u_short val; f = (gfloat)(scale) / (maxy - miny); for (i=0; i<count; i++) { val = base + (u_char) (vector[i] * f); fwrite(&val,sizeof(val),1,out); } } fclose (out); g_free (vector); }
void Dialog::UpdateData( bool retrieve ){ DLG_DATA *data; GSList *lst; char buf[32]; if ( retrieve ) { for ( lst = m_pDataList; lst != NULL; lst = g_slist_next( lst ) ) { data = (DLG_DATA*)lst->data; switch ( data->type ) { case DLG_CHECK_BOOL: *(bool*)data->buffer = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( data->object ) ); break; case DLG_RADIO_INT: { GSList *radio = gtk_radio_button_group( GTK_RADIO_BUTTON( data->object ) ); *(int*)data->buffer = g_slist_length( radio ) - 1; for (; radio; radio = g_slist_next( radio ) ) if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( radio->data ) ) ) { break; } else{ ( *(int*)data->buffer )--; } } break; case DLG_ENTRY_TEXT: { const char *txt; Str* str; str = (Str*)data->buffer; txt = gtk_entry_get_text( GTK_ENTRY( data->object ) ); *str = txt; } break; case DLG_ENTRY_FLOAT: *(float*)data->buffer = atof( gtk_entry_get_text( GTK_ENTRY( data->object ) ) ); break; case DLG_ENTRY_INT: *(int*)data->buffer = atoi( gtk_entry_get_text( GTK_ENTRY( data->object ) ) ); break; case DLG_SPIN_FLOAT: *(float*)data->buffer = gtk_spin_button_get_value_as_float( GTK_SPIN_BUTTON( data->object ) ); break; case DLG_SPIN_INT: *(int*)data->buffer = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON( data->object ) ); break; case DLG_ADJ_INT: *(int*)data->buffer = (int) GTK_ADJUSTMENT( data->object )->value; break; case DLG_COMBO_INT: { GList *lst = GTK_LIST( GTK_COMBO( data->object )->list )->children; char *label; const char *entry; int i; *(int*)data->buffer = -1; entry = gtk_entry_get_text( GTK_ENTRY( GTK_COMBO( data->object )->entry ) ); for ( i = 0; lst != NULL; lst = g_list_next( lst ) ) { gtk_label_get( GTK_LABEL( GTK_BIN( lst->data )->child ), &label ); if ( strcmp( label, entry ) == 0 ) { *(int*)data->buffer = i; break; } i++; } } break; case DLG_COMBO_BOX_INT: { *(int*)data->buffer = gtk_combo_box_get_active( GTK_COMBO_BOX( data->object ) ); } break; } } } else { for ( lst = m_pDataList; lst != NULL; lst = g_slist_next( lst ) ) { data = (DLG_DATA*)lst->data; switch ( data->type ) { case DLG_CHECK_BOOL: gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( data->object ), *(bool*)data->buffer ); break; case DLG_RADIO_INT: { GSList *radio = gtk_radio_button_group( GTK_RADIO_BUTTON( data->object ) ); gpointer btn = g_slist_nth_data( radio, g_slist_length( radio ) - ( *(int*)data->buffer ) - 1 ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( btn ), TRUE ); } break; case DLG_ENTRY_TEXT: { Str* str; str = (Str*)data->buffer; const char *txt = str->GetBuffer(); gtk_entry_set_text( GTK_ENTRY( data->object ), txt ); } break; case DLG_ENTRY_FLOAT: sprintf( buf, "%g", ( *(float*)data->buffer ) ); gtk_entry_set_text( GTK_ENTRY( data->object ), buf ); break; case DLG_ENTRY_INT: sprintf( buf, "%d", ( *(int*)data->buffer ) ); gtk_entry_set_text( GTK_ENTRY( data->object ), buf ); break; case DLG_SPIN_FLOAT: gtk_spin_button_set_value( GTK_SPIN_BUTTON( data->object ), ( *(float*)data->buffer ) ); break; case DLG_SPIN_INT: gtk_spin_button_set_value( GTK_SPIN_BUTTON( data->object ), ( *(int*)data->buffer ) ); break; case DLG_ADJ_INT: gtk_adjustment_set_value( GTK_ADJUSTMENT( data->object ), ( *(int*)data->buffer ) ); break; case DLG_COMBO_INT: { GList *lst = GTK_LIST( GTK_COMBO( data->object )->list )->children; char *entry = NULL; if ( *(int*)data->buffer != -1 ) { lst = g_list_nth( lst, *(int*)data->buffer ); if ( lst != NULL ) { gtk_label_get( GTK_LABEL( GTK_BIN( lst->data )->child ), &entry ); } } if ( entry ) { gtk_entry_set_text( GTK_ENTRY( GTK_COMBO( data->object )->entry ), entry ); } else{ gtk_entry_set_text( GTK_ENTRY( GTK_COMBO( data->object )->entry ), "" ); } } break; case DLG_COMBO_BOX_INT: { gtk_combo_box_set_active( GTK_COMBO_BOX( data->object ), *(int*)data->buffer ); } break; } } } }
/* Create the network */ void new_do_cb() { int i; int l[3]; l[0] = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(input_spin)); l[1] = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(hidden_spin)); l[2] = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(output_spin)); nn = mlp_new(l, 3); nn->transf_func = &heavyside; nn->transf_func_derivate = &heavyside_derivate; nn->learning_rate = gtk_spin_button_get_value_as_float(GTK_SPIN_BUTTON(learning_spin)); gtk_mlp_set_network(GTK_MLP(mlp), nn); // Add the input boxes in the main window neural_input = (GtkWidget **) malloc(sizeof(GtkWidget *) * l[0]); neural_output = (GtkWidget **) malloc(sizeof(GtkWidget *) * l[2]); gtk_box_pack_start(GTK_BOX(entry_box),gtk_label_new("Input values"),FALSE,FALSE,0); for(i = 0; i < l[0]; i++) { char str_c[16]; sprintf(str_c, "Neuron %d ", i); GtkWidget *tmp_box = gtk_hbox_new(0, 0); neural_input[i] = gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new((nn->input[i]).value, 0.0, 1.0, 0.02, (nn->input)[i].value, 0.1)), 1.0, 2); gtk_box_pack_start(GTK_BOX(tmp_box),gtk_label_new(str_c),FALSE,FALSE,0); gtk_box_pack_start(GTK_BOX(tmp_box),neural_input[i],TRUE,TRUE,0); gtk_box_pack_start(GTK_BOX(entry_box),tmp_box,FALSE,FALSE,0); gtk_widget_show_all(window); } gtk_box_pack_start(GTK_BOX(entry_box),gtk_label_new("Output values"),FALSE,FALSE,0); for(i = 0; i < l[2]; i++) { char str_c[16]; sprintf(str_c, "Neuron %d ", i); GtkWidget *tmp_box = gtk_hbox_new(0, 0); neural_output[i] = gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new((nn->output)[i].value, 0.0, 1.0, 0.02, (nn->output)[i].value, 0.1)), 1.0, 2); gtk_box_pack_start(GTK_BOX(tmp_box),gtk_label_new(str_c),FALSE,FALSE,0); gtk_box_pack_start(GTK_BOX(tmp_box),neural_output[i],TRUE,TRUE,0); gtk_box_pack_start(GTK_BOX(entry_box),tmp_box,FALSE,FALSE,0); gtk_widget_show_all(window); } gtk_statusbar_push(GTK_STATUSBAR(status_bar), 0, "Network created."); // Destroy the window gtk_widget_destroy(new_w); }
/* ============== GetTexMods Reads the fields to get the current texdef (i.e. widgets -> MAP) in brush primitive mode, grab the fake shift scale rot and compute a new texture matrix =============== */ void SurfaceDlg::GetTexMods(){ char buffer[1024]; texdef_t *pt; #ifdef DBG_SI Sys_Printf( "SurfaceDlg::GetTexMods\n" ); #endif if ( g_ptrSelectedFaces.GetSize() > 0 ) { //++timo just a test, we disable the undo when working on selected faces m_nUndoId = 0; face_t *selFace = reinterpret_cast<face_t*>( g_ptrSelectedFaces.GetAt( 0 ) ); g_qeglobals.d_texturewin.texdef = selFace->texdef; #ifdef DBG_SI Sys_Printf( "g_qeglobals.d_texturewin.texdef = selFace->texdef\n" ); #endif } // else // { pt = &g_qeglobals.d_texturewin.texdef; #ifdef DBG_SI Sys_Printf( "pt = &g_qeglobals.d_texturewin.texdef\n" ); #endif // } const char* text = gtk_entry_get_text( GTK_ENTRY( GetDlgWidget( "texture" ) ) ); #ifdef DBG_SI Sys_Printf( "pt->SetName(%s)\n", text ); #endif // TTimo: detect and refuse invalid texture names (at least the ones with spaces) if ( text[0] <= ' ' || strchr( text, ' ' ) ) { Sys_FPrintf( SYS_WRN, "WARNING: spaces in shader names are not allowed, ignoring '%s'\n", text ); pt->SetName( SHADER_NOT_FOUND ); gtk_entry_set_text( GTK_ENTRY( GetDlgWidget( "texture" ) ), pt->GetName() ); } else { strcpy( buffer, "textures/" ); strcpy( buffer + 9, text ); pt->SetName( buffer ); } ( g_qeglobals.m_bBrushPrimitMode ? m_shift[0] : pt->shift[0] ) = gtk_spin_button_get_value_as_float( GTK_SPIN_BUTTON( GetDlgWidget( "hshift" ) ) ); ( g_qeglobals.m_bBrushPrimitMode ? m_shift[1] : pt->shift[1] ) = gtk_spin_button_get_value_as_float( GTK_SPIN_BUTTON( GetDlgWidget( "vshift" ) ) ); ( g_qeglobals.m_bBrushPrimitMode ? m_scale[0] : pt->scale[0] ) = gtk_spin_button_get_value_as_float( GTK_SPIN_BUTTON( GetDlgWidget( "hscale" ) ) ); ( g_qeglobals.m_bBrushPrimitMode ? m_scale[1] : pt->scale[1] ) = gtk_spin_button_get_value_as_float( GTK_SPIN_BUTTON( GetDlgWidget( "vscale" ) ) ); ( g_qeglobals.m_bBrushPrimitMode ? m_rotate : pt->rotate ) = gtk_spin_button_get_value_as_float( GTK_SPIN_BUTTON( GetDlgWidget( "rotate" ) ) ); // a local copy of the texture matrix, given for a qtexture_t with width=2 height=2 brushprimit_texdef_t local_bp; brushprimit_texdef_t *bpt; if ( g_qeglobals.m_bBrushPrimitMode ) { face_t *selFace = NULL; if ( g_ptrSelectedFaces.GetSize() > 0 ) { selFace = reinterpret_cast<face_t*>( g_ptrSelectedFaces.GetAt( 0 ) ); bpt = &selFace->brushprimit_texdef; } else { bpt = &g_qeglobals.d_texturewin.brushprimit_texdef; } // compute texture matrix // the matrix returned must be understood as a qtexture_t with width=2 height=2 FakeTexCoordsToTexMat( m_shift, m_rotate, m_scale, local_bp.coords ); // copy the texture matrix in the global struct // fit the qtexture if we have a face selected, otherwise g_qeglobals.d_texturewin.brushprimit_texdef uses the basic qtexture_t with width=2 height=2 ConvertTexMatWithQTexture( &local_bp, NULL, bpt, ( ( selFace ) ? selFace->d_texture : NULL ) ); } // we are gonna do stuff, if we own the last do we undo it first if ( m_nUndoId != 0 ) { // check the do we're about to undo is the one we pushed earlier if ( m_nUndoId == Undo_GetUndoId() ) { #ifdef DBG_SI Sys_Printf( "GetTexMods calling Undo_Undo (silent)\n" ); #endif g_bListenUpdate = false; Undo_Undo( true ); g_bListenUpdate = true; } } Select_SetTexture( pt,&local_bp ); m_nUndoId = Undo_GetUndoId(); }
void FloatSpinnerExport(GtkSpinButton& widget, const FloatImportCallback& importCallback) { importCallback(float(gtk_spin_button_get_value_as_float(&widget))); }
void Calcul_pret ( GtkWidget *p_Widget, gpointer data ) { // Conversion des datas dans une structure ELEMENT ELEMENT *Recup = data; // Variables récupération des données gint i = 0; gint Paie_1 = 0; gint Paie_2 = 0; gfloat Taux_interet = 0; gint Duree_emprunt = 0; gint Somme_emprunt = 0; float Montant_mensualite = 0; float Montant = 0; float Mensualite_amortis = 0; float Mensualite_interet = 0; float Restant = 0; gchar *p_text_1 = NULL; // Récupération des informations Paie_1 = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (Recup -> p_Selecteur[0])); Paie_2 = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (Recup -> p_Selecteur[1])); Taux_interet = gtk_spin_button_get_value_as_float (GTK_SPIN_BUTTON (Recup -> p_Selecteur[2])); Duree_emprunt = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (Recup -> p_Selecteur[3])); Somme_emprunt = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (Recup -> p_Selecteur[4])); // Calcule et affichae la mensualité Montant_mensualite = Mensualite(Somme_emprunt, Duree_emprunt,Taux_interet); p_text_1 = g_strdup_printf("%.2f €",Montant_mensualite); gtk_label_set_text(GTK_LABEL (Recup->p_Etiq[16]),p_text_1); // Calcule et affiche le montant maximal de la mensualité Montant = Mensualite_max(Paie_1, Paie_2, Duree_emprunt, Taux_interet); p_text_1 = g_strdup_printf("%.2f €",Montant); gtk_label_set_text(GTK_LABEL (Recup->p_Etiq[17]),p_text_1); // Calcule et affiche le pourcentage d'endettement Montant = Endettement(Paie_1, Paie_2, Somme_emprunt, Duree_emprunt, Taux_interet); p_text_1 = g_strdup_printf("%.2f %%",Montant); gtk_label_set_text(GTK_LABEL (Recup->p_Etiq[18]),p_text_1); // Calcule et affiche la capacité d'emprunt Montant = Emprunt_max(Paie_1, Paie_2, Duree_emprunt, Taux_interet); p_text_1 = g_strdup_printf("%.0f €",Montant); gtk_label_set_text(GTK_LABEL (Recup->p_Etiq[19]),p_text_1); // Calcule et affiche Le montant des intérêts Montant = Interet(Somme_emprunt, Duree_emprunt,Taux_interet); p_text_1 = g_strdup_printf("%.0f €",Montant); gtk_label_set_text(GTK_LABEL (Recup->p_Etiq[20]),p_text_1); // Calcule le coût du crédit p_text_1 = g_strdup_printf("%.0f €",(Montant + Somme_emprunt) ); gtk_label_set_text(GTK_LABEL (Recup->p_Etiq[21]),p_text_1); // Efface le tableau if (GTK_IS_LIST_STORE(Recup->p_Modele)) { gtk_list_store_clear(GTK_LIST_STORE(Recup->p_Modele)); } // Remplit le tableau for( i = 1; i < ( Duree_emprunt * 12 ) + 1; i++ ) { // Calcule l'amortissement Mensualite_amortis = Amortissement(Somme_emprunt, Duree_emprunt, Taux_interet,i); Mensualite_interet = Montant_mensualite - Mensualite_amortis; Restant = Capital_rembourser(Somme_emprunt, Duree_emprunt, Taux_interet,i); Ajout_list( Recup -> p_Modele, i, Montant_mensualite, Mensualite_interet, Mensualite_amortis, Somme_emprunt - Restant ); } // Libére la mémoire }
double pgin_read_double(char *name, char *label, double def, double min, double max, double inc, int digits){ GtkWidget *dialog; GtkWidget *vbox; GtkWidget *action; GtkWidget *lbl; GtkWidget *spin_button; GtkWidget *ok_button; GtkObject *adj; double d; /* Dialog */ dialog = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(dialog), name); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); gtk_window_set_policy(GTK_WINDOW(dialog), TRUE, TRUE, FALSE); gtk_window_set_modal(GTK_WINDOW(dialog), TRUE); gtk_signal_connect(GTK_OBJECT(dialog), "delete_event", GTK_SIGNAL_FUNC(gtk_iface_grab_end_click), NULL); /* Vbox */ vbox = GTK_DIALOG(dialog)->vbox; gtk_container_set_border_width(GTK_CONTAINER(vbox), 4); gtk_widget_show(vbox); /* Label */ lbl = gtk_label_new(label); gtk_widget_show(lbl); gtk_container_add(GTK_CONTAINER(vbox), lbl); /* Spin button */ adj = gtk_adjustment_new(def, min, max, inc, inc, inc); spin_button = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 0, digits); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin_button), TRUE); gtk_widget_show(spin_button); gtk_container_add(GTK_CONTAINER(vbox), spin_button); /* Action area */ action = GTK_DIALOG(dialog)->action_area; gtk_container_set_border_width(GTK_CONTAINER(vbox), 4); gtk_widget_show(action); /* OK button */ ok_button = gtk_button_new_with_label(" OK "); gtk_widget_show(ok_button); gtk_container_add(GTK_CONTAINER(action), ok_button); gtk_signal_connect(GTK_OBJECT(ok_button), "clicked", GTK_SIGNAL_FUNC(gtk_iface_grab_end_click), NULL); /* Get input */ gtk_widget_show(dialog); gtk_iface_grab_end = 0; while (!gtk_iface_grab_end){ while (gtk_events_pending()) gtk_main_iteration(); usleep(10000); } /* Get value */ d = gtk_spin_button_get_value_as_float(GTK_SPIN_BUTTON(spin_button)); /* Destroy */ gtk_widget_destroy(lbl); gtk_widget_destroy(spin_button); gtk_widget_destroy(ok_button); gtk_widget_destroy(vbox); gtk_widget_destroy(dialog); //gtk_object_destroy(adj); return d; }
void ChangeDoubleVal(GtkWidget *widget,gpointer data) { *((gdouble *)data)=gtk_spin_button_get_value_as_float (GTK_SPIN_BUTTON(widget)); }