static void update_label (NautilusFloatingBar *self) { gtk_label_set_text (GTK_LABEL (self->priv->label_widget), self->priv->label); }
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++ Main +++++++++++++++++++++++++++++++++++++++++++++++++++++++ */ uint8_t ADM_ocr_engine( void) { // uint32_t nbSub=0; FILE *out=NULL; head.next=NULL; ADMVideoVobSub *vobsub=NULL; uint32_t startTime,endTime; uint32_t w,h,oldw=0,oldh=0; uint32_t oldbitmapw=0; uint32_t oldbitmaph=0; uint32_t first,last; uint32_t seqNum; char text[1024]; lang_index=0; nbGlyphs=0; ReplyType reply; // Create UI && prepare callback dialog=DIA_ocr(); gtk_register_dialog(dialog); #define ASSOCIATE(x,y) gtk_dialog_add_action_widget (GTK_DIALOG (dialog), WID(x),y) ASSOCIATE(buttonStart,actionGo); ASSOCIATE(buttonOk, actionAccept); ASSOCIATE(buttonSkip, actionSkip); ASSOCIATE(buttonSkipAll, actionSkipAll); ASSOCIATE(buttonIgnore, actionIgnore); ASSOCIATE(buttonCalibrate, actionCalibrate); ASSOCIATE(buttonGlyphLoad, actionLoadGlyph); ASSOCIATE(buttonGlyphSave, actionSaveGlyph); ASSOCIATE(buttonVobsub, actionLoadVob); ASSOCIATE(buttonSrt, actionSaveSub); gtk_widget_show(dialog); // disable mainDisplay=WID(drawingareaBitmap); smallDisplay=WID(drawingareaSmall); CONNECT(drawingareaBitmap,expose_event,gui_draw); CONNECT(drawingareaSmall,expose_event,gui_draw_small); CONNECT(entry,activate,cb_accept); _again: reply=setup(); if(reply==ReplyClose) goto endIt; printf("Go go go\n"); // Everything ready go go go redraw_x=redraw_y=0; GTK_PURGE; // Time to go // Inactivate frame1=glyph frame2=in/out buttonStart gtk_widget_set_sensitive(WID(buttonStart),0); gtk_widget_set_sensitive(WID(frameGlyph),0); gtk_widget_set_sensitive(WID(frameLoad),0); gtk_widget_set_sensitive(WID(frameBitmap),1); gtk_widget_set_sensitive(WID(buttonStart),0); char *fileout; fileout=(char *)gtk_label_get_text(GTK_LABEL(WID(labelSrt))); if(!fileout) { GUI_Error_HIG(_("Incorrect output file"), NULL); goto _again; } out=fopen(fileout,"wb"); if(!out) { GUI_Error_HIG(_("Output file error"), _("Could not open \"%s\" for writing."), fileout); goto _again; } vobsub=new ADMVideoVobSub(subparam.subname,subparam.index); nbSub=vobsub->getNbImage(); if(!nbSub) { GUI_Error_HIG(_("Problem loading sub"), NULL); delete vobsub; vobsub=NULL; goto _again; } seqNum=1; // Sub number in srt file oldw=oldh=0; //****************** // Load all bitmaps //****************** for(uint32_t i=0;i<nbSub;i++) { first=last=0; bitmap=vobsub->getBitmap(i,&startTime, &endTime,&first,&last); ADM_assert(last>=first); // something ? if(!bitmap) continue; if(first==last) continue; // If the bitmap size changed or does not exist yet... if(!workArea || oldbitmapw!=bitmap->_width || oldbitmaph!=bitmap->_height) { if(workArea) { delete [] workArea; workArea=NULL; } // Workarea is actually bigger than what we use workArea=new uint8_t[bitmap->_width*(bitmap->_height)]; memset(workArea,0,bitmap->_width*(bitmap->_height)); } oldbitmaph=bitmap->_height; oldbitmapw=bitmap->_width; // w=bitmap->_width; h=last-first+1; redraw_x=w; redraw_y=h; //** // Build againPlease: mergeBitmap(bitmap->_bitmap+first*w, workArea, bitmap->_alphaMask+first*w, w, h); if(oldw!=w || oldh !=h) { GTK_PURGE; // Force redaw } // Merge GTK_PURGE; gui_draw(); GTK_PURGE; // OCR reply=ocrBitmap(workArea,w,h); if(reply==ReplyClose) goto endIt; if(reply==ReplyCalibrate) { // //printf("TADA!!!!\n"); int val; #if 0 val=minAlpha; if(DIA_GetIntegerValue(&val, 3, 7, "Minimum alpha value", "Enter new minimum alpha")) { minAlpha=val; } #endif val=minThreshold; if(DIA_GetIntegerValue(&val, 0x30, 0x80, "Minimum pixel value", "Enter new minimum pixel")) { minThreshold=val; } goto againPlease; } // gtk_label_set_text(GTK_LABEL(WID(labelText)),decodedString); fprintf(out,"%d\n",seqNum++); uint16_t hh,mm,ss,ms; ms2time(startTime, &hh, &mm, &ss, &ms); fprintf(out,"%02d:%02d:%02d,%03d --> ",hh,mm,ss,ms); ms2time(endTime, &hh, &mm, &ss, &ms); fprintf(out,"%02d:%02d:%02d,%03d\n",hh,mm,ss,ms); fprintf(out,"%s\n\n",decodedString); // oldw=w; oldh=h; // Update infos sprintf(text,"%03d/%03d",i+1,nbSub); gtk_label_set_text(GTK_LABEL(WID(labelNbLines)),text); sprintf(text,"%03d",nbGlyphs); gtk_label_set_text(GTK_LABEL(WID(labelNbGlyphs)),text); } endIt: // Final round gtk_widget_set_sensitive(WID(frameGlyph),1); gtk_widget_set_sensitive(WID(frameLoad),0); gtk_widget_set_sensitive(WID(buttonStart),0); gtk_widget_set_sensitive(WID(frameBitmap),0); // gtk_widget_set_sensitive(WID(Current_Glyph),0); if(nbGlyphs && actionSaveGlyph==gtk_dialog_run(GTK_DIALOG(dialog))) saveGlyph(); if(vobsub) delete vobsub; vobsub=NULL; if(out) fclose(out); out=NULL; gtk_unregister_dialog(dialog); gtk_widget_destroy(dialog); if(head.next) destroyGlyphTree(&head); head.next=NULL; return 1; }
/****************************************************************************************** Setup (input/output files etc..) *****************************************************************************************/ ReplyType setup(void) { int sel; char text[1024]; while(1) { //gtk_widget_set_sensitive(WID(buttonAccept),0); //gtk_widget_set_sensitive(WID(buttonSkip),0); //gtk_widget_set_sensitive(WID(entryEntry),0); GTK_PURGE; // Main loop : Only accept glyph load/save // Sub & srt select & start ocr gtk_widget_set_sensitive(WID(frameGlyph),1); gtk_widget_set_sensitive(WID(frameLoad),1); gtk_widget_set_sensitive(WID(buttonStart),1); gtk_widget_set_sensitive(WID(frameBitmap),0); //gtk_widget_set_sensitive(WID(Current_Glyph),0); switch(sel=gtk_dialog_run(GTK_DIALOG(dialog))) { case actionLoadVob: { subparam.index=lang_index; subparam.subname=NULL; if(DIA_vobsub(&subparam)) { lang_index=subparam.index; gtk_label_set_text(GTK_LABEL(WID(labelVobsub)),subparam.subname); } } break; case actionSaveSub: { char *srt=NULL; GUI_FileSelWrite(_("Select SRT to save"), &srt); if(srt) { gtk_label_set_text(GTK_LABEL(WID(labelSrt)),srt); } } break; case actionLoadGlyph: { char *gly=NULL; GUI_FileSelRead(_("Select Glyoh to save"), &gly); if(gly) { loadGlyph(gly); sprintf(text,"%03d",nbGlyphs); gtk_label_set_text(GTK_LABEL(WID(labelNbGlyphs)),text); } } break; case actionSaveGlyph: if(!nbGlyphs) { GUI_Error_HIG(_("No glyphs to save"), NULL); break; } saveGlyph(); break; case GTK_RESPONSE_CLOSE: printf("Close req\n"); return ReplyClose; default: printf("Other input:%d\n",sel); } // Everything selected, check if(sel==actionGo) return ReplyOk; } }
void entry_dialog_set_label (EntryDialog* self, const char* text) { g_return_if_fail (self != NULL); g_return_if_fail (text != NULL); gtk_label_set_text (self->priv->label, text); }
void pLabel::setText(string text) { gtk_label_set_text(GTK_LABEL(gtkWidget), text); }
static GtkCellEditable * egg_cell_renderer_keys_start_editing (GtkCellRenderer *cell, GdkEvent *event, GtkWidget *widget, const gchar *path, GdkRectangle *background_area, GdkRectangle *cell_area, GtkCellRendererState flags) { GtkCellRendererText *celltext; EggCellRendererKeys *keys; GtkWidget *label; GtkWidget *eventbox; GValue celltext_editable = {0}; celltext = GTK_CELL_RENDERER_TEXT (cell); keys = EGG_CELL_RENDERER_KEYS (cell); /* If the cell isn't editable we return NULL. */ g_value_init (&celltext_editable, G_TYPE_BOOLEAN); g_object_get_property (G_OBJECT (celltext), "editable", &celltext_editable); if (g_value_get_boolean (&celltext_editable) == FALSE) return NULL; g_return_val_if_fail (gtk_widget_get_window (widget) != NULL, NULL); if (gdk_keyboard_grab (gtk_widget_get_window (widget), FALSE, gdk_event_get_time (event)) != GDK_GRAB_SUCCESS) return NULL; if (gdk_pointer_grab (gtk_widget_get_window (widget), FALSE, GDK_BUTTON_PRESS_MASK, NULL, NULL, gdk_event_get_time (event)) != GDK_GRAB_SUCCESS) { gdk_keyboard_ungrab (gdk_event_get_time (event)); return NULL; } keys->grab_widget = widget; g_signal_connect (G_OBJECT (widget), "key_press_event", G_CALLBACK (grab_key_callback), keys); eventbox = g_object_new (pointless_eventbox_subclass_get_type (), NULL); keys->edit_widget = eventbox; g_object_add_weak_pointer (G_OBJECT (keys->edit_widget), (void**) &keys->edit_widget); label = gtk_label_new (NULL); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); #else gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); #endif gtk_widget_modify_bg (eventbox, GTK_STATE_NORMAL, >k_widget_get_style (widget)->bg[GTK_STATE_SELECTED]); gtk_widget_modify_fg (label, GTK_STATE_NORMAL, >k_widget_get_style (widget)->fg[GTK_STATE_SELECTED]); gtk_label_set_text (GTK_LABEL (label), TOOLTIP_TEXT); gtk_container_add (GTK_CONTAINER (eventbox), label); g_object_set_data_full (G_OBJECT (keys->edit_widget), EGG_CELL_RENDERER_TEXT_PATH, g_strdup (path), g_free); gtk_widget_show_all (keys->edit_widget); g_signal_connect (G_OBJECT (keys->edit_widget), "unrealize", G_CALLBACK (ungrab_stuff), keys); keys->edit_key = keys->accel_key; return GTK_CELL_EDITABLE (keys->edit_widget); }
gboolean gnc_ab_enter_daterange(GtkWidget *parent, const char *heading, Timespec *from_date, gboolean *last_retv_date, gboolean *first_possible_date, Timespec *to_date, gboolean *to_now) { GtkBuilder *builder; GtkWidget *dialog; GtkWidget *heading_label; GtkWidget *first_button; GtkWidget *last_retrieval_button; GtkWidget *now_button; DaterangeInfo info; gint result; ENTER(""); builder = gtk_builder_new(); gnc_builder_add_from_file (builder, "dialog-ab.glade", "aqbanking_date_range_dialog"); dialog = GTK_WIDGET(gtk_builder_get_object (builder, "aqbanking_date_range_dialog")); /* Connect the signals */ gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, &info ); if (parent) gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(parent)); heading_label = GTK_WIDGET(gtk_builder_get_object (builder, "heading_label")); first_button = GTK_WIDGET(gtk_builder_get_object (builder, "first_button")); last_retrieval_button = GTK_WIDGET(gtk_builder_get_object (builder, "last_retrieval_button")); info.enter_from_button = GTK_WIDGET(gtk_builder_get_object (builder, "enter_from_button")); now_button = GTK_WIDGET(gtk_builder_get_object (builder, "now_button")); info.enter_to_button = GTK_WIDGET(gtk_builder_get_object (builder, "enter_to_button")); info.from_dateedit = gnc_date_edit_new_ts(*from_date, FALSE, FALSE); gtk_container_add(GTK_CONTAINER(gtk_builder_get_object (builder, "enter_from_box")), info.from_dateedit); gtk_widget_show(info.from_dateedit); info.to_dateedit = gnc_date_edit_new_ts(*to_date, FALSE, FALSE); gtk_container_add(GTK_CONTAINER(gtk_builder_get_object (builder, "enter_to_box")), info.to_dateedit); gtk_widget_show(info.to_dateedit); if (*last_retv_date) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(last_retrieval_button), TRUE); } else { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(first_button), TRUE); gtk_widget_set_sensitive(last_retrieval_button, FALSE); } gtk_widget_set_sensitive(info.from_dateedit, FALSE); gtk_widget_set_sensitive(info.to_dateedit, FALSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); if (heading) gtk_label_set_text(GTK_LABEL(heading_label), heading); gtk_widget_show(dialog); result = gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_hide(dialog); if (result == GTK_RESPONSE_OK) { *from_date = gnc_date_edit_get_date_ts( GNC_DATE_EDIT(info.from_dateedit)); *last_retv_date = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(last_retrieval_button)); *first_possible_date = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(first_button)); *to_date = gnc_date_edit_get_date_ts( GNC_DATE_EDIT(info.to_dateedit)); *to_now = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(now_button)); } g_object_unref(G_OBJECT(builder)); gtk_widget_destroy(dialog); LEAVE(""); return result == GTK_RESPONSE_OK; }
static GtkWidget *create_dialog(void) { GtkWidget *dialog; GtkWidget *header_image; GtkWidget *header_label; GtkWidget *label_info; GtkWidget *codename_label; GtkWidget *builddate_label; GtkWidget *url_button; GtkWidget *cop_label; GtkWidget *label; GtkWidget *license_textview; GtkWidget *notebook; GtkWidget *box; GtkWidget *credits_scrollwin; GtkWidget *table; GtkWidget *license_scrollwin; GtkWidget *info_box; GtkWidget *header_hbox; GtkWidget *header_eventbox; GtkTextBuffer* tb; gchar *license_text = NULL; gchar buffer[512]; gchar buffer2[128]; guint i, row = 0; gchar *build_date; dialog = gtk_dialog_new(); /* configure dialog */ gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window)); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany")); gtk_window_set_icon_name(GTK_WINDOW(dialog), "geany"); gtk_widget_set_name(dialog, "GeanyDialog"); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL); /* create header */ header_eventbox = gtk_event_box_new(); gtk_widget_show(header_eventbox); header_hbox = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4); gtk_widget_show(header_hbox); gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox); header_image = gtk_image_new_from_icon_name("geany", GTK_ICON_SIZE_DIALOG); gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0); header_label = gtk_label_new(NULL); gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE); /* print the subversion revision generated by ./configure if it is available */ g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string()); gtk_label_set_markup(GTK_LABEL(header_label), buffer); gtk_widget_show(header_label); gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0); header_eventbox_style_set(header_eventbox); header_label_style_set(header_label); g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL); g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), header_eventbox, FALSE, FALSE, 0); /* create notebook */ notebook = gtk_notebook_new(); gtk_widget_show(notebook); gtk_container_set_border_width(GTK_CONTAINER(notebook), 2); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), notebook, TRUE, TRUE, 0); /* create "Info" tab */ info_box = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(info_box), 6); gtk_widget_show(info_box); label_info = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(label_info), TRUE); gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE); g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE")); gtk_label_set_markup(GTK_LABEL(label_info), buffer); gtk_misc_set_padding(GTK_MISC(label_info), 2, 11); gtk_widget_show(label_info); gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0); /* Codename label */ codename_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE); gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME); gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8); gtk_widget_show(codename_label); gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0); /* build date label */ builddate_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE); build_date = utils_parse_and_format_build_date(__DATE__); g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), build_date); g_free(build_date); g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2); gtk_label_set_markup(GTK_LABEL(builddate_label), buffer); gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2); gtk_widget_show(builddate_label); gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0); box = gtk_hbutton_box_new(); url_button = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE); g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE); label = gtk_label_new(NULL); gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE); gtk_widget_show(label); gtk_container_add(GTK_CONTAINER(url_button), label); gtk_widget_show(url_button); gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0); gtk_widget_show(box); gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10); /* copyright label */ cop_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE); gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE); gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT); gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10); gtk_widget_show(cop_label); gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0); /*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */ label = gtk_label_new(_("Info")); gtk_widget_show(label); gtk_widget_show_all(info_box); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label); /* create "Credits" tab */ credits_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 6); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE); gtk_table_set_col_spacings(GTK_TABLE(table), 10); row = 0; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < translators_len; i++) { ROW(translators[i][0], row, 0, 1, 4, 0); ROW(translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < prev_translators_len; i++) { ROW(prev_translators[i][0], row, 0, 1, 4, 0); ROW(prev_translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; g_snprintf(buffer, sizeof(buffer), _("Some of the many contributors (for a more detailed list, see the file %s):"), #ifdef G_OS_WIN32 "Thanks.txt" #else "THANKS" #endif ); label = geany_wrap_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; label = geany_wrap_label_new(contributors); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table); gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE); gtk_widget_show_all(table); label = gtk_label_new(_("Credits")); gtk_widget_show(label); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label); /* create "License" tab */ license_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_SHADOW_IN); license_textview = gtk_text_view_new(); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(license_textview), 2); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(license_textview), 2); gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE); gtk_widget_show(license_textview); gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview); label = gtk_label_new(_("License")); gtk_widget_show(label); g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir); g_file_get_contents(buffer, &license_text, NULL, NULL); if (license_text == NULL) { license_text = g_strdup( _("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online.")); } tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview)); gtk_text_buffer_set_text(tb, license_text, -1); g_free(license_text); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label); gtk_widget_show_all(dialog); return dialog; }
static void device_status_cb (NmaBtDevice *device, GParamSpec *pspec, WidgetInfo *info) { gtk_label_set_text (GTK_LABEL (info->status), nma_bt_device_get_status (device)); }
static void grouplist_dialog_set_list(const gchar *pattern, gboolean refresh) { static GdkCursor *watch_cursor = NULL; GSList *cur; GtkCMCTreeNode *node; GPatternSpec *pspec; GdkWindow *window; if (locked) return; locked = TRUE; if (!pattern || *pattern == '\0') pattern = "*"; if (!watch_cursor) watch_cursor = gdk_cursor_new(GDK_WATCH); window = gtk_widget_get_window(dialog); gdk_window_set_cursor(window, watch_cursor); main_window_cursor_wait(mainwindow_get_mainwindow()); GTK_EVENTS_FLUSH(); if (refresh) { ack = TRUE; grouplist_clear(); recv_set_ui_func(grouplist_recv_func, NULL); group_list = news_get_group_list(news_folder); group_list = g_slist_reverse(group_list); recv_set_ui_func(NULL, NULL); if (group_list == NULL && ack == TRUE) { alertpanel_error(_("Can't retrieve newsgroup list.")); locked = FALSE; gdk_window_set_cursor(window, NULL); main_window_cursor_normal(mainwindow_get_mainwindow()); return; } } else gtk_cmclist_clear(GTK_CMCLIST(ctree)); gtk_entry_set_text(GTK_ENTRY(entry), pattern); grouplist_hash_init(); gtk_cmclist_freeze(GTK_CMCLIST(ctree)); pspec = g_pattern_spec_new(pattern); for (cur = group_list; cur != NULL ; cur = cur->next) { NewsGroupInfo *ginfo = (NewsGroupInfo *)cur->data; if (g_pattern_match_string(pspec, ginfo->name)) { node = grouplist_create_branch(ginfo, pattern); if (g_slist_find_custom(subscribed, ginfo->name, (GCompareFunc)g_ascii_strcasecmp) != NULL) gtk_cmctree_select(GTK_CMCTREE(ctree), node); } } for (cur = subscribed; cur; cur = g_slist_next(cur)) grouplist_expand_upwards(GTK_CMCTREE(ctree), (gchar *)cur->data); g_pattern_spec_free(pspec); gtk_cmclist_thaw(GTK_CMCLIST(ctree)); grouplist_hash_done(); gtk_label_set_text(GTK_LABEL(status_label), _("Done.")); gdk_window_set_cursor(window, NULL); main_window_cursor_normal(mainwindow_get_mainwindow()); locked = FALSE; }
gboolean update_page_name(GtkWidget *window, GtkWidget *vte, gchar *page_name, GtkWidget *label, gint page_no, gchar *custom_page_name, const gchar *tab_color, gboolean is_root, gboolean is_bold, gboolean show_encoding, gchar *encoding_str, gboolean custom_window_title, gboolean lost_focus) { #ifdef DETAIL g_debug("! Launch update_page_name() with vte = %p, label_name = %s, page_no = %d, " "custom_page_name = %s, tab_color = %s, is_root = %d, is_bold = %d, " "show_encoding = %d, encoding_str = %s", vte, page_name, page_no, custom_page_name, tab_color, is_root, is_bold, show_encoding, encoding_str); #endif #ifdef DEFENSIVE if (vte==NULL) return FALSE; #endif // page_name = NULL when initing a new page. if (page_name == NULL) { struct Page *page_data = (struct Page *)g_object_get_data(G_OBJECT(vte), "Page_Data"); #ifdef DEFENSIVE if (page_data==NULL) return FALSE; #endif // g_debug("page_name = NULL!! trying to call get_and_update_page_name()"); get_and_update_page_name(page_data, FALSE); } gboolean page_name_updated = FALSE; struct Window *win_data = (struct Window *)g_object_get_data(G_OBJECT(window), "Win_Data"); #ifdef DEFENSIVE if (win_data==NULL) return FALSE; #endif // We don't update label name when the size of window is changing. // 0xfe = 11,111,110 // g_debug("win_data->keep_vte_size = %x", win_data->keep_vte_size); #ifdef USE_GTK2_GEOMETRY_METHOD if (!(win_data->keep_vte_size&0xfffc)) { #endif // g_debug("Updating %d page name to %s...", page_no, page_name); gchar *label_name = NULL; if (custom_page_name==NULL) label_name = page_name; else label_name = custom_page_name; #ifdef ENABLE_SET_TOOLTIP_TEXT if (! lost_focus) gtk_widget_set_tooltip_text(label, label_name); #endif // g_debug("[1] Updating %d page name to %s...", page_no, label_name); // FIXME: label_name = NULL when initing page. if (label_name==NULL) return FALSE; if (win_data->page_shows_number) label_name = g_strdup_printf("(%d) %s", page_no, label_name); else label_name = g_strdup(label_name); // g_debug("[2] Updating %d page name to %s...", page_no, label_name); // label_name will be freed later. if (win_data->page_shows_encoding && show_encoding && encoding_str) { gchar *temp_str = g_strdup_printf("%s (%s)", label_name, encoding_str); g_free(label_name); label_name = temp_str; // g_debug("[3] Updating %d page name to %s...", page_no, label_name); } // if the window is lost focus, don't update the tab name // g_debug("lost_focus = %d", lost_focus); if (! lost_focus) { // win_data->keep_vte_size |= 1; // g_debug("window_resizable in update_page_name! and keep_vte_size =%d", keep_vte_size); // window_resizable(window, vte, 2, 1); // DANGEROUS: remark the following keep_window_size() // will break the geometry of window when drag and drop. // g_debug("update_page_name(): launch keep_window_size()!"); #ifdef USE_GTK2_GEOMETRY_METHOD # ifdef GEOMETRY g_debug("@ update_page_name(): Call keep_gtk2_window_size() with keep_vte_size = %x", win_data->keep_vte_size); # endif keep_gtk2_window_size (win_data, vte, 0x3); #endif #ifdef USE_GTK3_GEOMETRY_METHOD win_data->keep_vte_size++; #endif if (win_data->use_color_page && (tab_color != NULL)) { // g_debug("[Debug] Updating %d page name to %s...", page_no, label_name); gchar *color_label_name; if (is_bold) color_label_name = convert_text_to_html (&label_name, FALSE, (gchar *)tab_color, "b", NULL); else color_label_name = convert_text_to_html (&label_name, FALSE, (gchar *)tab_color, NULL); gtk_label_set_markup (GTK_LABEL(label), color_label_name); // g_debug("[FINAL] Updating %d page name to %s...", page_no, color_label_name); g_free(color_label_name); } else gtk_label_set_text(GTK_LABEL(label), label_name); // g_debug("Updated the tab name to %s!", page_name); page_name_updated = TRUE; } // else // g_debug("!!! the window is lost focus, don't update the tab name"); // free the data g_free(label_name); #ifdef USE_GTK2_GEOMETRY_METHOD } #endif // we should update window title if page name changed. check_and_update_window_title(win_data, custom_window_title, page_no, custom_page_name, page_name); // g_debug("(update_page_name): page_name_updated = %d", page_name_updated); return page_name_updated; }
int handle_api(void) { static int step = 0; int bytes; int i=0; char buff[32]; // ATPL4 = power level 4 // ATMT0 = zero retry on broadcast // ATRR = mac retry on NACK // ATDH = 0x00000000 // ATDL = 0x0000FFFF // read only: // Serial High // Serial Low // ATDC = duty cycle status (percent 0 - 100) // ATDB = Signal Strength // ATWR = write to flash // ATCN = exit command mode step++; if (step > 35) { step = 35; return 1; } switch(step) { case 1: sprintf(buff,"+++"); bytes = write(fd, buff, strlen(buff)); printf("+++ (bytes=%d %d)\n",bytes, fd); buff[strlen(buff)] = 0; strcpy(status_ivy_str,buff); gtk_label_set_text( GTK_LABEL(status_ivy), status_ivy_str ); break; case 8: sprintf(buff,"ATPL\r"); write(fd, (unsigned char*) buff, strlen(buff)); printf("ATPL\n"); buff[strlen(buff) - 1] = 0; strcpy(status_ivy_str,buff); gtk_label_set_text( GTK_LABEL(status_ivy), status_ivy_str ); break; case 10: sprintf(buff,"ATPL%d\r", power_level); write(fd, (unsigned char*) buff, strlen(buff)); printf("ATPL%d\n",power_level); buff[strlen(buff) - 1] = 0; strcpy(status_ivy_str,buff); gtk_label_set_text( GTK_LABEL(status_ivy), status_ivy_str ); break; case 12: sprintf(buff,"ATPL\r"); write(fd, (unsigned char*) buff, strlen(buff)); printf("ATPL\n"); buff[strlen(buff) - 1] = 0; strcpy(status_ivy_str,buff); gtk_label_set_text( GTK_LABEL(status_ivy), status_ivy_str ); break; case 14: sprintf(buff,"ATDH\r"); write(fd, (unsigned char*) buff, strlen(buff)); printf("ATDH\n"); buff[strlen(buff) - 1] = 0; strcpy(status_ivy_str,buff); gtk_label_set_text( GTK_LABEL(status_ivy), status_ivy_str ); break; case 16: sprintf(buff,"ATDL\r"); write(fd, (unsigned char*) buff, strlen(buff)); printf("ATDL\n"); buff[strlen(buff) - 1] = 0; strcpy(status_ivy_str,buff); gtk_label_set_text( GTK_LABEL(status_ivy), status_ivy_str ); break; case 18: sprintf(buff,"ATSH\r"); write(fd, (unsigned char*) buff, strlen(buff)); printf("ATSH\n"); buff[strlen(buff) - 1] = 0; strcpy(status_ivy_str,buff); gtk_label_set_text( GTK_LABEL(status_ivy), status_ivy_str ); break; case 20: sprintf(buff,"ATSL\r"); write(fd, (unsigned char*) buff, strlen(buff)); printf("ATSL\n"); buff[strlen(buff) - 1] = 0; strcpy(status_ivy_str,buff); gtk_label_set_text( GTK_LABEL(status_ivy), status_ivy_str ); break; case 22: sprintf(buff,"ATMT0\r"); write(fd, (unsigned char*) buff, strlen(buff)); printf("ATMT0\n"); buff[strlen(buff) - 1] = 0; strcpy(status_ivy_str,buff); gtk_label_set_text( GTK_LABEL(status_ivy), status_ivy_str ); break; case 24: sprintf(buff,"ATRR0\r"); write(fd, (unsigned char*) buff, strlen(buff)); printf("ATRR0\n"); buff[strlen(buff) - 1] = 0; strcpy(status_ivy_str,buff); gtk_label_set_text( GTK_LABEL(status_ivy), status_ivy_str ); break; case 26: sprintf(buff,"ATDH00000000\r"); write(fd, (unsigned char*) buff, strlen(buff)); printf("ATDH00000000\n"); buff[strlen(buff) - 1] = 0; strcpy(status_ivy_str,buff); gtk_label_set_text( GTK_LABEL(status_ivy), status_ivy_str ); break; case 28: sprintf(buff,"ATDL0000FFFF\r"); write(fd, (unsigned char*) buff, strlen(buff)); printf("ATDL0000FFFF\n"); buff[strlen(buff) - 1] = 0; strcpy(status_ivy_str,buff); gtk_label_set_text( GTK_LABEL(status_ivy), status_ivy_str ); break; case 30: sprintf(buff,"ATWR\r"); write(fd, (unsigned char*) buff, strlen(buff)); printf("ATWR\n"); buff[strlen(buff) - 1] = 0; strcpy(status_ivy_str,buff); gtk_label_set_text( GTK_LABEL(status_ivy), status_ivy_str ); break; case 32: sprintf(buff,"ATCN\r"); write(fd, (unsigned char*) buff, strlen(buff)); printf("ATCN\n"); printf("Quit API\n"); modem_id[16]=0; sprintf(buff, ", XB_ADDR='%s', ", modem_id); strcat(status_str,buff); sprintf(buff, "ATPL=%d", power_level); strcat(status_str,buff); gtk_label_set_text( GTK_LABEL(status), status_str ); break; case 34: sprintf(status_ivy_str, "---"); gtk_label_set_text( GTK_LABEL(status_ivy), status_ivy_str ); sprintf(status_serial_str, "---"); gtk_label_set_text( GTK_LABEL(status_serial), status_serial_str ); break; case 7: case 9: case 11: case 13: case 15: case 17: case 19: case 21: case 23: case 25: case 27: case 29: case 31: case 33: bytes = read(fd, (unsigned char*) buff, 32); printf("Bytes %d %d\n",bytes, fd); if ((bytes > 1) && (bytes < 10)) { buff[bytes-1] = 0; strcpy(status_serial_str, buff); gtk_label_set_text( GTK_LABEL(status_serial), status_serial_str ); } for (i=0;i<bytes;i++) { printf("%c",buff[i]); if ((step == 13) && (i==0)) { power_level = (int)buff[0] - (int)'0'; } else if (step == 19) { if ((buff[i] != '\r') && (buff[i] != '\n')) { modem_id[strlen(modem_id)] = buff[i]; modem_id[strlen(modem_id)+1] = 0; } } else if (step == 21) { if ((buff[i] != '\r') && (buff[i] != '\n')) { modem_id[strlen(modem_id)] = buff[i]; modem_id[strlen(modem_id)+1] = 0; } } } printf("\n"); break; } return 0; }
void send_ivy(void) { float phi,theta,psi,z,zdot; if (new_serial_data == 0) return; new_serial_data = 0; phi = ((float) remote_uav.phi) / 1000.0f; theta = ((float) remote_uav.theta) / 1000.0f; psi = ((float) remote_uav.psi) / 1000.0f; IvySendMsg("%d ALIVE 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n", remote_uav.ac_id); IvySendMsg("%d ATTITUDE %f %f %f\n", remote_uav.ac_id, phi, psi, theta); /* remote_uav.utm_east = local_uav.utm_east; remote_uav.utm_north = local_uav.utm_north + 5000; remote_uav.utm_z = local_uav.utm_z + 1000; remote_uav.utm_zone = local_uav.utm_zone; remote_uav.speed = local_uav.speed * 4; remote_uav.psi += 30.; */ /* <message name="GPS" id="8"> <field name="mode" type="uint8" unit="byte_mask"/> <field name="utm_east" type="int32" unit="cm" alt_unit="m"/> <field name="utm_north" type="int32" unit="cm" alt_unit="m"/> <field name="course" type="int16" unit="decideg" alt_unit="deg"/> <field name="alt" type="int32" unit="mm" alt_unit="m"/> <field name="speed" type="uint16" unit="cm/s" alt_unit="m/s"/> <field name="climb" type="int16" unit="cm/s" alt_unit="m/s"/> <field name="week" type="uint16" unit="weeks"/> <field name="itow" type="uint32" unit="ms"/> <field name="utm_zone" type="uint8"/> <field name="gps_nb_err" type="uint8"/> </message> */ IvySendMsg("%d GPS 3 %d %d 0 %d %d 0 0 0 %d 0\n", remote_uav.ac_id, remote_uav.utm_east, remote_uav.utm_north, remote_uav.utm_z, remote_uav.speed, remote_uav.utm_zone); /* <message name="FBW_STATUS" id="103"> <field name="rc_status" type="uint8" values="OK|LOST|REALLY_LOST"/> <field name="frame_rate" type="uint8" unit="Hz"/> <field name="mode" type="uint8" values="MANUAL|AUTO|FAILSAFE"/> <field name="vsupply" type="uint8" unit="decivolt"/> <field name="current" type="int32" unit="mA"/> </message> */ IvySendMsg("%d FBW_STATUS 2 0 1 81 0 \n", remote_uav.ac_id); z = ((float)remote_uav.utm_z) / 1000.0f; zdot = remote_uav.climb; IvySendMsg("%d ESTIMATOR %f %f \n", remote_uav.ac_id, z, zdot); /* <message name="DESIRED" id="16"> <field name="roll" type="float" format="%.2f" unit="rad" alt_unit="deg" alt_unit_coef="57.3"/> <field name="pitch" type="float" format="%.2f" unit="rad" alt_unit="deg" alt_unit_coef="57.3"/> <field name="course" type="float" format="%.1f" unit="rad" alt_unit="deg" alt_unit_coef="57.3"/> <field name="x" type="float" format="%.0f" unit="m"/> <field name="y" type="float" format="%.0f" unit="m"/> <field name="altitude" type="float" format="%.0f" unit="m"/> <field name="climb" type="float" format="%.1f" unit="m/s"></field> </message> */ IvySendMsg("%d DESIRED 0 0 0 0 0 %f 0 \n", remote_uav.ac_id, remote_uav.desired_alt); /* <message name="NAVIGATION" id="10"> <field name="cur_block" type="uint8"/> <field name="cur_stage" type="uint8"/> <field name="pos_x" type="float" unit="m" format="%.1f"/> <field name="pos_y" type="float" unit="m" format="%.1f"/> <field name="dist2_wp" type="float" format="%.1f" unit="m^2"/> <field name="dist2_home" type="float" format="%.1f" unit="m^2"/> <field name="circle_count" type="uint8"/> <field name="oval_count" type="uint8"/> </message> */ // IvySendMsg("%d NAVIGATION %d 0 0 0 0 0 0 0 \n", remote_uav.ac_id, remote_uav.block); /* <message name="BAT" id="12"> <field name="throttle" type="int16" unit="pprz"/> <field name="voltage" type="uint8" unit="1e-1V" alt_unit="V" alt_unit_coef="0.1"/> <field name="amps" type="int16" unit="A" alt_unit="A" /> <field name="flight_time" type="uint16" unit="s"/> <field name="kill_auto_throttle" type="uint8" unit="bool"/> <field name="block_time" type="uint16" unit="s"/> <field name="stage_time" type="uint16" unit="s"/> <field name="energy" type="int16" unit="mAh"/> </message> */ // IvySendMsg("%d BAT 0 81 0 %ld 0 0 0 0\n", remote_uav.ac_id, count_serial); /* <message name="PPRZ_MODE" id="11"> <field name="ap_mode" type="uint8" values="MANUAL|AUTO1|AUTO2|HOME|NOGPS|FAILSAFE"/> <field name="ap_gaz" type="uint8" values="MANUAL|AUTO_THROTTLE|AUTO_CLIMB|AUTO_ALT"/> <field name="ap_lateral" type="uint8" values="MANUAL|ROLL_RATE|ROLL|COURSE"/> <field name="ap_horizontal" type="uint8" values="WAYPOINT|ROUTE|CIRCLE"/> <field name="if_calib_mode" type="uint8" values="NONE|DOWN|UP"/> <field name="mcu1_status" type="uint8" values="LOST|OK|REALLY_LOST"/> </message> */ // IvySendMsg("%d PPRZ_MODE 0 0 0 0 0 0\n", remote_uav.ac_id); /* // Needed to show any NAV info like current block number <message name="NAVIGATION_REF" id="9"> <field name="utm_east" type="int32" unit="m"/> <field name="utm_north" type="int32" unit="m"/> <field name="utm_zone" type="uint8"/> </message> */ static int delayer = 10; delayer++; if (delayer > 5) { // IvySendMsg("%d NAVIGATION_REF %d %d %d\n", remote_uav.ac_id, remote_uav.utm_east, remote_uav.utm_north, remote_uav.utm_zone); delayer = 0; } count_serial++; sprintf(status_serial_str, "Read %d from '%s': forwarding to IVY [%ld] {Rx=%ld} {Err=%ld}", remote_uav.ac_id, port, count_serial, rx_bytes, rx_error); gtk_label_set_text( GTK_LABEL(status_serial), status_serial_str ); }
gint display_infos_dbox() { GladeXML *xml; GtkWidget *dbox; GtkWidget *label; gint result; gchar *str; xml = glade_xml_new (tilp_paths_build_glade("infos-2.glade"), "infos_dbox", PACKAGE); if (!xml) g_error(_("%s: GUI loading failed !\n"), __FILE__); glade_xml_signal_autoconnect(xml); dbox = glade_xml_get_widget(xml, "infos_dbox"); label = glade_xml_get_widget(xml, "label20"); str = g_strdup_printf("%s", "TiEmu v2.00"); gtk_label_set_text(GTK_LABEL(label), str); g_free(str); label = glade_xml_get_widget(xml, "label21"); str = g_strdup_printf("%s", skin_infos.name); gtk_label_set_text(GTK_LABEL(label), str); g_free(str); label = glade_xml_get_widget(xml, "label22"); str = g_strdup_printf("%s", skin_infos.author); gtk_label_set_text(GTK_LABEL(label), str); g_free(str); label = glade_xml_get_widget(xml, "label23"); str = g_strdup_printf("%s", ti68k_calctype_to_string(tihw.calc_type)); gtk_label_set_text(GTK_LABEL(label), str); g_free(str); label = glade_xml_get_widget(xml, "label24"); str = g_strdup_printf("%s", tihw.rom_version); gtk_label_set_text(GTK_LABEL(label), str); g_free(str); label = glade_xml_get_widget(xml, "label25"); str = g_strdup_printf("%i KB", tihw.ram_size >> 10); gtk_label_set_text(GTK_LABEL(label), str); g_free(str); label = glade_xml_get_widget(xml, "label26"); str = g_strdup_printf("%i KB", tihw.rom_size >> 10); gtk_label_set_text(GTK_LABEL(label), str); g_free(str); label = glade_xml_get_widget(xml, "label27"); str = g_strdup_printf("%s", ti68k_romtype_to_string(tihw.rom_flash | tihw.rom_internal)); gtk_label_set_text(GTK_LABEL(label), str); g_free(str); label = glade_xml_get_widget(xml, "label28"); str = g_strdup_printf("%s", ti68k_hwtype_to_string(tihw.hw_type)); gtk_label_set_text(GTK_LABEL(label), str); g_free(str); result = gtk_dialog_run(GTK_DIALOG(dbox)); switch (result) { case GTK_RESPONSE_OK: ti68k_engine_unhalt(); break; default: break; } gtk_widget_destroy(dbox); return 0; }
void ghb_set_preview_image(signal_user_data_t *ud) { GtkWidget *widget; gint preview_width, preview_height, target_height, width, height; g_debug("set_preview_button_image ()"); gint title_id, titleindex; const hb_title_t *title; live_preview_stop(ud); title_id = ghb_dict_get_int(ud->settings, "title"); title = ghb_lookup_title(title_id, &titleindex); if (title == NULL) return; widget = GHB_WIDGET (ud->builder, "preview_frame"); ud->preview->frame = ghb_widget_int(widget) - 1; if (ud->preview->encoded[ud->preview->frame]) { widget = GHB_WIDGET(ud->builder, "live_progress_box"); gtk_widget_hide (widget); widget = GHB_WIDGET(ud->builder, "live_preview_progress"); gtk_widget_show (widget); } else { widget = GHB_WIDGET(ud->builder, "live_preview_progress"); gtk_widget_hide (widget); widget = GHB_WIDGET(ud->builder, "live_progress_box"); gtk_widget_show (widget); widget = GHB_WIDGET(ud->builder, "live_encode_progress"); gtk_progress_bar_set_text(GTK_PROGRESS_BAR(widget), ""); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(widget), 0); } if (ud->preview->pix != NULL) g_object_unref(ud->preview->pix); ud->preview->pix = ghb_get_preview_image(title, ud->preview->frame, ud, &width, &height); if (ud->preview->pix == NULL) return; preview_width = gdk_pixbuf_get_width(ud->preview->pix); preview_height = gdk_pixbuf_get_height(ud->preview->pix); widget = GHB_WIDGET (ud->builder, "preview_image"); if (preview_width != ud->preview->width || preview_height != ud->preview->height) { preview_set_size(ud, preview_width, preview_height); } gtk_widget_queue_draw(widget); gchar *text = g_strdup_printf("%d x %d", width, height); widget = GHB_WIDGET (ud->builder, "preview_dims"); gtk_label_set_text(GTK_LABEL(widget), text); g_free(text); g_debug("preview %d x %d", preview_width, preview_height); target_height = MIN(ud->preview->button_height, 200); height = target_height; width = preview_width * height / preview_height; if (width > 400) { width = 400; height = preview_height * width / preview_width; } if ((height >= 16) && (width >= 16)) { GdkPixbuf *scaled_preview; scaled_preview = gdk_pixbuf_scale_simple (ud->preview->pix, width, height, GDK_INTERP_NEAREST); if (scaled_preview != NULL) { widget = GHB_WIDGET (ud->builder, "preview_button_image"); gtk_image_set_from_pixbuf(GTK_IMAGE(widget), scaled_preview); g_object_unref(scaled_preview); } } }
/* update all "dynamic" things */ void range_update_dynamics(gpointer data) { packet_range_t *range; GtkWidget *range_displayed_bt; gboolean filtered_active; gint selected_num; gboolean can_select; gboolean selected_packets; gchar label_text[100]; guint32 ignored_cnt = 0, displayed_ignored_cnt = 0; guint32 displayed_cnt; range = (packet_range_t *)g_object_get_data(G_OBJECT(data), RANGE_VALUES_KEY); range_displayed_bt = (GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_DISPLAYED_BT_KEY); filtered_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(range_displayed_bt)); /* Enable saving only the displayed packets only if there *are* displayed packets. */ if (range->displayed_cnt != 0) gtk_widget_set_sensitive(range_displayed_bt, TRUE); else { /* If saving the displayed packets is selected, select saving the captured packets. */ filtered_active = FALSE; gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(G_OBJECT(data), RANGE_SELECT_ALL_KEY)), FALSE); gtk_widget_set_sensitive(range_displayed_bt, FALSE); } /* All / Captured */ gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_ALL_C_KEY), !filtered_active); if (range->remove_ignored) { g_snprintf(label_text, sizeof(label_text), "%u", cfile.count - range->ignored_cnt); } else { g_snprintf(label_text, sizeof(label_text), "%u", cfile.count); } gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_ALL_C_KEY)), label_text); /* All / Displayed */ gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_ALL_D_KEY), filtered_active); if (range->include_dependents) displayed_cnt = range->displayed_plus_dependents_cnt; else displayed_cnt = range->displayed_cnt; if (range->remove_ignored) { g_snprintf(label_text, sizeof(label_text), "%u", displayed_cnt - range->displayed_ignored_cnt); } else { g_snprintf(label_text, sizeof(label_text), "%u", displayed_cnt); } gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_ALL_D_KEY)), label_text); /* Selected / Captured + Displayed */ /* Enable saving the currently-selected packet only if there *is* a currently-selected packet. */ selected_num = (cfile.current_frame) ? cfile.current_frame->num : 0; can_select = (selected_num != 0); if (can_select) { gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_CURR_KEY), TRUE); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_CURR_C_KEY), !filtered_active); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_CURR_D_KEY), filtered_active); } else { /* If "save selected packet" is selected, select "save all packets". */ if (range->process == range_process_selected) { range->process = range_process_all; gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(G_OBJECT(data), RANGE_SELECT_ALL_KEY)), TRUE); } gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_CURR_KEY), FALSE); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_CURR_C_KEY), FALSE); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_CURR_D_KEY), FALSE); } /* XXX: how to update the radio button label but keep the mnemonic? */ /*g_snprintf(label_text, sizeof(label_text), "_Selected packet #%u only", selected_num); gtk_label_set_text(GTK_LABEL(GTK_BIN(select_curr_rb)->child), label_text);*/ if (range->remove_ignored && can_select && cfile.current_frame->flags.ignored) { g_snprintf(label_text, sizeof(label_text), "0"); } else { g_snprintf(label_text, sizeof(label_text), "%u", selected_num ? 1 : 0); } gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_CURR_C_KEY)), label_text); if (range->remove_ignored && can_select && cfile.current_frame->flags.ignored) { g_snprintf(label_text, sizeof(label_text), "0"); } else { g_snprintf(label_text, sizeof(label_text), "%u", selected_num ? 1 : 0); } gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_CURR_D_KEY)), label_text); /* Marked / Captured + Displayed */ /* Enable the buttons for saving marked packets only if there *are* marked packets. */ if (filtered_active) selected_packets = (range->displayed_marked_cnt != 0); else selected_packets = (cfile.marked_count > 0); if (selected_packets) { gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_KEY), TRUE); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_C_KEY), !filtered_active); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_D_KEY), filtered_active); } else { /* If "save marked packet" is selected, select "save all packets". */ if (range->process == range_process_marked) { range->process = range_process_all; gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(G_OBJECT(data), RANGE_SELECT_ALL_KEY)), TRUE); } gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_KEY), FALSE); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_C_KEY), FALSE); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_D_KEY), FALSE); } if (range->remove_ignored) { g_snprintf(label_text, sizeof(label_text), "%u", cfile.marked_count - range->ignored_marked_cnt); } else { g_snprintf(label_text, sizeof(label_text), "%u", cfile.marked_count); } gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_C_KEY)), label_text); if (range->remove_ignored) { g_snprintf(label_text, sizeof(label_text), "%u", range->displayed_marked_cnt - range->displayed_ignored_marked_cnt); } else { g_snprintf(label_text, sizeof(label_text), "%u", range->displayed_marked_cnt); } gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_D_KEY)), label_text); /* First to last marked / Captured + Displayed */ /* Enable the buttons for saving the range of marked packets only if there *is* a range of marked packets. */ if (filtered_active) selected_packets = (range->displayed_mark_range_cnt != 0); else selected_packets = (range->mark_range_cnt != 0); if (selected_packets) { gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_RANGE_KEY), TRUE); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_RANGE_C_KEY), !filtered_active); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_RANGE_D_KEY), filtered_active); } else { /* If "save range between first and last marked packet" is selected, select "save all packets". */ if (range->process == range_process_marked_range) { range->process = range_process_all; gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(G_OBJECT(data), RANGE_SELECT_ALL_KEY)), TRUE); } gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_RANGE_KEY), FALSE); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_RANGE_C_KEY), FALSE); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_RANGE_D_KEY), FALSE); } if (range->remove_ignored) { g_snprintf(label_text, sizeof(label_text), "%u", range->mark_range_cnt - range->ignored_mark_range_cnt); } else { g_snprintf(label_text, sizeof(label_text), "%u", range->mark_range_cnt); } gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_RANGE_C_KEY)), label_text); if (range->remove_ignored) { g_snprintf(label_text, sizeof(label_text), "%u", range->displayed_mark_range_cnt - range->displayed_ignored_mark_range_cnt); } else { g_snprintf(label_text, sizeof(label_text), "%u", range->displayed_mark_range_cnt); } gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_RANGE_D_KEY)), label_text); /* User specified / Captured + Displayed */ gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_USER_KEY), TRUE); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_USER_C_KEY), !filtered_active); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_USER_D_KEY), filtered_active); if (range->remove_ignored) { g_snprintf(label_text, sizeof(label_text), "%u", range->user_range_cnt - range->ignored_user_range_cnt); } else { g_snprintf(label_text, sizeof(label_text), "%u", range->user_range_cnt); } gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_USER_C_KEY)), label_text); if (range->remove_ignored) { g_snprintf(label_text, sizeof(label_text), "%u", range->displayed_user_range_cnt - range->displayed_ignored_user_range_cnt); } else { g_snprintf(label_text, sizeof(label_text), "%u", range->displayed_user_range_cnt); } gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_USER_D_KEY)), label_text); /* Ignored */ switch(range->process) { case(range_process_all): ignored_cnt = range->ignored_cnt; displayed_ignored_cnt = range->displayed_ignored_cnt; break; case(range_process_selected): ignored_cnt = (can_select && cfile.current_frame->flags.ignored) ? 1 : 0; displayed_ignored_cnt = ignored_cnt; break; case(range_process_marked): ignored_cnt = range->ignored_marked_cnt; displayed_ignored_cnt = range->displayed_ignored_marked_cnt; break; case(range_process_marked_range): ignored_cnt = range->ignored_mark_range_cnt; displayed_ignored_cnt = range->displayed_ignored_mark_range_cnt; break; case(range_process_user_range): ignored_cnt = range->ignored_user_range_cnt; displayed_ignored_cnt = range->displayed_ignored_user_range_cnt; break; default: g_assert_not_reached(); } if (filtered_active) selected_packets = (displayed_ignored_cnt != 0); else selected_packets = (ignored_cnt != 0); if (selected_packets) { gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_REMOVE_IGNORED_KEY), TRUE); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_IGNORED_C_KEY), !filtered_active); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_IGNORED_D_KEY), filtered_active); } else { gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_REMOVE_IGNORED_KEY), FALSE); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_IGNORED_C_KEY), FALSE); gtk_widget_set_sensitive((GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_IGNORED_D_KEY), FALSE); } g_snprintf(label_text, sizeof(label_text), "%u", ignored_cnt); gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_IGNORED_C_KEY)), label_text); g_snprintf(label_text, sizeof(label_text), "%u", displayed_ignored_cnt); gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_IGNORED_D_KEY)), label_text); }
static void theme_message_area_update (AppearanceData *data) { const MateThemeMetaInfo *theme; gboolean show_apply_background = FALSE; gboolean show_apply_font = FALSE; gboolean show_revert_font = FALSE; gboolean show_error; const gchar *message; gchar *font; GError *error = NULL; theme = theme_get_selected (GTK_ICON_VIEW (appearance_capplet_get_widget (data, "theme_list")), data); if (!theme) { if (data->theme_message_area != NULL) gtk_widget_hide (data->theme_message_area); return; } show_error = !mate_theme_meta_info_validate (theme, &error); if (!show_error) { if (theme->background_image != NULL) { gchar *background; background = g_settings_get_string (data->wp_settings, WP_FILE_KEY); show_apply_background = (!background || strcmp (theme->background_image, background) != 0); g_free (background); } if (theme->application_font) { font = g_settings_get_string (data->interface_settings, GTK_FONT_KEY); show_apply_font = (!font || strcmp (theme->application_font, font) != 0); g_free (font); } if (!show_apply_font && theme->documents_font) { font = g_settings_get_string (data->interface_settings, DOCUMENT_FONT_KEY); show_apply_font = (!font || strcmp (theme->application_font, font) != 0); g_free (font); } if (!show_apply_font && theme->desktop_font) { font = g_settings_get_string (data->caja_settings, DESKTOP_FONT_KEY); show_apply_font = (!font || strcmp (theme->application_font, font) != 0); g_free (font); } if (!show_apply_font && theme->windowtitle_font) { font = g_settings_get_string (data->marco_settings, WINDOW_TITLE_FONT_KEY); show_apply_font = (!font || strcmp (theme->application_font, font) != 0); g_free (font); } if (!show_apply_font && theme->monospace_font) { font = g_settings_get_string (data->interface_settings, MONOSPACE_FONT_KEY); show_apply_font = (!font || strcmp (theme->application_font, font) != 0); g_free (font); } show_revert_font = (data->revert_application_font != NULL || data->revert_documents_font != NULL || data->revert_desktop_font != NULL || data->revert_windowtitle_font != NULL || data->revert_monospace_font != NULL); } if (data->theme_message_area == NULL) { GtkWidget *hbox; GtkWidget *parent; GtkWidget *content; if (!show_apply_background && !show_revert_font && !show_apply_font && !show_error) return; data->theme_message_area = gtk_info_bar_new (); gtk_widget_set_no_show_all (data->theme_message_area, TRUE); g_signal_connect (data->theme_message_area, "response", (GCallback) theme_message_area_response_cb, data); data->apply_background_button = gtk_info_bar_add_button ( GTK_INFO_BAR (data->theme_message_area), _("Apply Background"), RESPONSE_APPLY_BG); data->apply_font_button = gtk_info_bar_add_button ( GTK_INFO_BAR (data->theme_message_area), _("Apply Font"), RESPONSE_APPLY_FONT); data->revert_font_button = gtk_info_bar_add_button ( GTK_INFO_BAR (data->theme_message_area), _("Revert Font"), RESPONSE_REVERT_FONT); data->install_button = gtk_info_bar_add_button ( GTK_INFO_BAR (data->theme_message_area), _("Install"), RESPONSE_INSTALL_ENGINE); data->theme_message_label = gtk_label_new (NULL); gtk_widget_show (data->theme_message_label); gtk_label_set_line_wrap (GTK_LABEL (data->theme_message_label), TRUE); gtk_misc_set_alignment (GTK_MISC (data->theme_message_label), 0.0, 0.5); hbox = gtk_hbox_new (FALSE, 9); gtk_widget_show (hbox); data->theme_info_icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG); data->theme_error_icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (data->theme_info_icon), 0.5, 0); gtk_misc_set_alignment (GTK_MISC (data->theme_error_icon), 0.5, 0); gtk_box_pack_start (GTK_BOX (hbox), data->theme_info_icon, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), data->theme_error_icon, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), data->theme_message_label, TRUE, TRUE, 0); content = gtk_info_bar_get_content_area (GTK_INFO_BAR (data->theme_message_area)); gtk_container_add (GTK_CONTAINER (content), hbox); parent = appearance_capplet_get_widget (data, "theme_list_vbox"); gtk_box_pack_start (GTK_BOX (parent), data->theme_message_area, FALSE, FALSE, 0); } if (show_error) message = error->message; else if (show_apply_background && show_apply_font && show_revert_font) message = _("The current theme suggests a background and a font. Also, the last applied font suggestion can be reverted."); else if (show_apply_background && show_revert_font) message = _("The current theme suggests a background. Also, the last applied font suggestion can be reverted."); else if (show_apply_background && show_apply_font) message = _("The current theme suggests a background and a font."); else if (show_apply_font && show_revert_font) message = _("The current theme suggests a font. Also, the last applied font suggestion can be reverted."); else if (show_apply_background) message = _("The current theme suggests a background."); else if (show_revert_font) message = _("The last applied font suggestion can be reverted."); else if (show_apply_font) message = _("The current theme suggests a font."); else message = NULL; if (show_apply_background) gtk_widget_show (data->apply_background_button); else gtk_widget_hide (data->apply_background_button); if (show_apply_font) gtk_widget_show (data->apply_font_button); else gtk_widget_hide (data->apply_font_button); if (show_revert_font) gtk_widget_show (data->revert_font_button); else gtk_widget_hide (data->revert_font_button); if (show_error && g_error_matches (error, MATE_THEME_ERROR, MATE_THEME_ERROR_GTK_ENGINE_NOT_AVAILABLE) && packagekit_available ()) gtk_widget_show (data->install_button); else gtk_widget_hide (data->install_button); if (show_error || show_apply_background || show_apply_font || show_revert_font) { gtk_widget_show (data->theme_message_area); gtk_widget_queue_draw (data->theme_message_area); if (show_error) { gtk_widget_show (data->theme_error_icon); gtk_widget_hide (data->theme_info_icon); } else { gtk_widget_show (data->theme_info_icon); gtk_widget_hide (data->theme_error_icon); } } else { gtk_widget_hide (data->theme_message_area); } gtk_label_set_text (GTK_LABEL (data->theme_message_label), message); g_clear_error (&error); }
static void update_examples_cb (GtkTreeSelection *selection, gpointer user_data) { GtkBuilder *builder = GTK_BUILDER (user_data); GtkTreeModel *model; GtkTreeIter iter; gchar *active_id; gchar *locale; GDateTime *dt; gchar *s; struct lconv *num_info; const char *fmt; if (!gtk_tree_selection_get_selected (selection, &model, &iter)) { return; } gtk_tree_model_get (model, &iter, 0, &active_id, -1); locale = g_strdup (setlocale (LC_TIME, NULL)); setlocale (LC_TIME, active_id); dt = g_date_time_new_now_local (); /* Display dates */ display_date (GTK_LABEL (gtk_builder_get_object (builder, "full_date_format")), dt, "%A %e %B %Y"); display_date (GTK_LABEL (gtk_builder_get_object (builder, "full_day_format")), dt, "%e %B %Y"); display_date (GTK_LABEL (gtk_builder_get_object (builder, "short_day_format")), dt, "%e %b %Y"); display_date (GTK_LABEL (gtk_builder_get_object (builder, "shortest_day_format")), dt, "%x"); /* Display times */ display_date (GTK_LABEL (gtk_builder_get_object (builder, "full_time_format")), dt, "%r %Z"); display_date (GTK_LABEL (gtk_builder_get_object (builder, "short_time_format")), dt, "%X"); setlocale (LC_TIME, locale); g_free (locale); /* Display numbers */ locale = g_strdup (setlocale (LC_NUMERIC, NULL)); setlocale (LC_NUMERIC, active_id); s = g_strdup_printf ("%'.2f", 123456789.00); gtk_label_set_text (GTK_LABEL (gtk_builder_get_object (builder, "numbers_format")), s); g_free (s); setlocale (LC_NUMERIC, locale); g_free (locale); /* Display currency */ locale = g_strdup (setlocale (LC_MONETARY, NULL)); setlocale (LC_MONETARY, active_id); num_info = localeconv (); if (num_info != NULL) { gtk_label_set_text (GTK_LABEL (gtk_builder_get_object (builder, "currency_format")), num_info->currency_symbol); } setlocale (LC_MONETARY, locale); g_free (locale); /* Display measurement */ #ifdef LC_MEASUREMENT locale = g_strdup (setlocale (LC_MEASUREMENT, NULL)); setlocale (LC_MEASUREMENT, active_id); fmt = nl_langinfo (_NL_MEASUREMENT_MEASUREMENT); if (fmt && *fmt == 2) gtk_label_set_text (GTK_LABEL (gtk_builder_get_object (builder, "measurement_format")), _("Imperial")); else gtk_label_set_text (GTK_LABEL (gtk_builder_get_object (builder, "measurement_format")), _("Metric")); setlocale (LC_MEASUREMENT, locale); g_free (locale); #endif g_free (active_id); }
/** * table_output: * * Update the given widgets table with the values from the track stats */ static void table_output ( track_stats ts, GtkWidget *content[], gboolean extended ) { int cnt = 0; gchar tmp_buf[64]; g_snprintf ( tmp_buf, sizeof(tmp_buf), "%d", ts.count ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.count == 0 ) { // Blank all other fields g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); for ( cnt = 1; cnt < G_N_ELEMENTS(label_texts); cnt++ ) gtk_label_set_text ( GTK_LABEL(content[cnt]), tmp_buf ); return; } // Check for potential date range // Test if the same day by comparing the date string of the timestamp GDate* gdate_start = g_date_new (); g_date_set_time_t ( gdate_start, ts.start_time ); gchar time_start[32]; g_date_strftime ( time_start, sizeof(time_start), "%x", gdate_start ); g_date_free ( gdate_start ); GDate* gdate_end = g_date_new (); g_date_set_time_t ( gdate_end, ts.end_time ); gchar time_end[32]; g_date_strftime ( time_end, sizeof(time_end), "%x", gdate_end ); g_date_free ( gdate_end ); if ( ts.start_time == ts.end_time ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("No Data") ); else if ( strncmp(time_start, time_end, 32) ) g_snprintf ( tmp_buf, sizeof(tmp_buf), "%s --> %s", time_start, time_end ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "%s", time_start ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); switch (a_vik_get_units_distance ()) { case VIK_UNITS_DISTANCE_MILES: g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.1f miles"), VIK_METERS_TO_MILES(ts.length) ); break; case VIK_UNITS_DISTANCE_NAUTICAL_MILES: g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.1f NM"), VIK_METERS_TO_NAUTICAL_MILES(ts.length) ); break; default: //VIK_UNITS_DISTANCE_KILOMETRES g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.1f km"), ts.length/1000.0 ); break; } gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); switch (a_vik_get_units_distance ()) { case VIK_UNITS_DISTANCE_MILES: g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.2f miles"), (VIK_METERS_TO_MILES(ts.length)/ts.count) ); break; case VIK_UNITS_DISTANCE_NAUTICAL_MILES: g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.2f NM"), (VIK_METERS_TO_NAUTICAL_MILES(ts.length)/ts.count) ); break; default: //VIK_UNITS_DISTANCE_KILOMETRES g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.2f km"), ts.length/(1000.0*ts.count) ); break; } gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( extended ) { // Note that this currently is a simplified approach to calculate the Eddington number. // In that a per track value is used, rather than trying to work out a length per day. // (i.e. doesn't combine multiple tracks for a single day or split very long tracks into days) tracks_stats[TS_TRACKS].e_list = g_list_sort ( tracks_stats[TS_TRACKS].e_list, rsort_by_distance ); guint Eddington = 0; guint position = 0; for (GList *iter = g_list_first (tracks_stats[TS_TRACKS].e_list); iter != NULL; iter = g_list_next (iter)) { position++; gdouble *num = (gdouble*)iter->data; if ( *num > position ) Eddington = position; } g_snprintf ( tmp_buf, sizeof(tmp_buf), ("%d"), Eddington ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); } else cnt++; // I'm sure this could be cleaner... g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); switch (a_vik_get_units_speed()) { case VIK_UNITS_SPEED_MILES_PER_HOUR: if ( ts.max_speed > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.1f mph"), (double)VIK_MPS_TO_MPH(ts.max_speed) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.duration > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), ("%.1f mph"), (double)VIK_MPS_TO_MPH(ts.length/ts.duration) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); break; case VIK_UNITS_SPEED_METRES_PER_SECOND: if ( ts.max_speed > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.2f m/s"), (double)ts.max_speed ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.duration > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), ("%.2f m/s"), (double)(ts.length/ts.duration) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); break; case VIK_UNITS_SPEED_KNOTS: if ( ts.max_speed > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.2f knots"), (double)VIK_MPS_TO_KNOTS(ts.max_speed) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.duration > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.2f knots"), (double)VIK_MPS_TO_KNOTS(ts.length/ts.duration) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); break; case VIK_UNITS_SPEED_SECONDS_PER_KM: if ( ts.max_speed > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d s/km"), (int)VIK_MPS_TO_PACE_SPK(ts.max_speed) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.duration > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d s/km"), (int)VIK_MPS_TO_PACE_SPK(ts.length/ts.duration) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); break; case VIK_UNITS_SPEED_MINUTES_PER_KM: if ( ts.max_speed > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.1f min/km"), (double)VIK_MPS_TO_PACE_MPK(ts.max_speed) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.duration > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.1f min/km"), (double)VIK_MPS_TO_PACE_MPK(ts.length/ts.duration) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); break; case VIK_UNITS_SPEED_SECONDS_PER_MILE: if ( ts.max_speed > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d sec/mi"), (int)VIK_MPS_TO_PACE_SPM(ts.max_speed) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.duration > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d sec/mi"), (int)VIK_MPS_TO_PACE_SPM(ts.length/ts.duration) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); break; case VIK_UNITS_SPEED_MINUTES_PER_MILE: if ( ts.max_speed > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.1f min/mi"), (double)VIK_MPS_TO_PACE_MPM(ts.max_speed) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.duration > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.1f min/mi"), (double)VIK_MPS_TO_PACE_MPM(ts.length/ts.duration) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); break; default: //VIK_UNITS_SPEED_KILOMETRES_PER_HOUR: if ( ts.max_speed > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.2f km/h"), (double)VIK_MPS_TO_KPH(ts.max_speed) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.duration > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.2f km/h"), (double)VIK_MPS_TO_KPH(ts.length/ts.duration) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); break; } gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); switch ( a_vik_get_units_height() ) { // Note always round off height value output since sub unit accuracy is overkill case VIK_UNITS_HEIGHT_FEET: if ( ts.min_alt != VIK_VAL_MIN_ALT ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d feet"), (int)round(VIK_METERS_TO_FEET(ts.min_alt)) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.max_alt != VIK_VAL_MAX_ALT ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d feet"), (int)round(VIK_METERS_TO_FEET(ts.max_alt)) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d feet / %d feet"), (int)round(VIK_METERS_TO_FEET(ts.elev_gain)), (int)round(VIK_METERS_TO_FEET(ts.elev_loss)) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d feet / %d feet"), (int)round(VIK_METERS_TO_FEET(ts.elev_gain/ts.count)), (int)round(VIK_METERS_TO_FEET(ts.elev_loss/ts.count)) ); break; default: //VIK_UNITS_HEIGHT_METRES if ( ts.min_alt != VIK_VAL_MIN_ALT ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d m"), (int)round(ts.min_alt) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.max_alt != VIK_VAL_MAX_ALT ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d m"), (int)round(ts.max_alt) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d m / %d m"), (int)round(ts.elev_gain), (int)round(ts.elev_loss) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d m / %d m"), (int)round(ts.elev_gain/ts.count), (int)round(ts.elev_loss/ts.count) ); break; } gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); gint hours; gint minutes; gint days; // Total Duration days = (gint)(ts.duration / (60*60*24)); hours = (gint)floor((ts.duration - (days*60*60*24)) / (60*60)); minutes = (gint)((ts.duration - (days*60*60*24) - (hours*60*60)) / 60); g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d:%02d:%02d days:hrs:mins"), days, hours, minutes ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); // Average Duration gint avg_dur = ts.duration / ts.count; hours = (gint)floor(avg_dur / (60*60)); minutes = (gint)((avg_dur - (hours*60*60)) / 60); g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d:%02d hrs:mins"), hours, minutes ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); }
int main(int argc, char** argv) { //gtk wdiget init start... GtkWidget *window, *icon_view, *notebook; GtkWidget *current_user_name, *current_time, *network_speed; GtkWidget *home_button, *access_token_entry, *access_token_ok_button; GtkWidget *access_token_cancel_button; GtkWidget *get_access_token_button, *post_blog_title_entry; GtkWidget *post_blog_content_text_view, *post_blog_content_text_buffer; GtkWidget *post_blog_ok_button, *post_blog_cancel_button; GtkWidget *blog_access_permission, *blog_password; GList *post_blog_page = NULL; GtkBuilder *builder; GError *error = NULL; //widget init gtk_init(&argc, &argv); builder = gtk_builder_new(); if(!gtk_builder_add_from_file(builder, "./sources/glade.glade", &error)) { g_print("Error occured while loading UI files\n"); g_print("Message: %s\n", error->message); g_free(error); return 1; } //widget get from builder(glade files) window = GTK_WIDGET(gtk_builder_get_object(builder, "window")); notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook1")); icon_view = GTK_WIDGET(gtk_builder_get_object(builder, "iconview1")); current_user_name = GTK_WIDGET(gtk_builder_get_object(builder,"label4")); current_time = GTK_WIDGET(gtk_builder_get_object(builder, "label5")); network_speed = GTK_WIDGET(gtk_builder_get_object(builder, "label6")); access_token_ok_button = GTK_WIDGET(gtk_builder_get_object(builder, "button3")); access_token_cancel_button = GTK_WIDGET(gtk_builder_get_object(builder, "button6")); get_access_token_button = GTK_WIDGET(gtk_builder_get_object(builder, "button2")); home_button = GTK_WIDGET(gtk_builder_get_object(builder, "button1")); access_token_entry = GTK_WIDGET(gtk_builder_get_object(builder, "entry1")); post_blog_content_text_view= GTK_WIDGET(gtk_builder_get_object(builder, "textview1")); post_blog_ok_button = GTK_WIDGET(gtk_builder_get_object(builder, "button4")); post_blog_title_entry = GTK_WIDGET(gtk_builder_get_object(builder, "entry2")); blog_access_permission = GTK_WIDGET(gtk_builder_get_object(builder, "comboboxtext1")); blog_password = GTK_WIDGET(gtk_builder_get_object(builder, "entry4")); //set object attributes gtk_window_set_title(GTK_WINDOW(window), "Xiao nei Gtk App"); gtk_window_set_default_size(GTK_WINDOW(window), 800, 400); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_icon_view_set_model(GTK_ICON_VIEW(icon_view), create_model()); gtk_icon_view_set_text_column(GTK_ICON_VIEW(icon_view), COL_DISPLAY_NAME); gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(icon_view), COL_PIXBUF); gtk_icon_view_set_columns(GTK_ICON_VIEW(icon_view), 4); gtk_label_set_text(GTK_LABEL(current_user_name), "Current user:fengtianba"); g_timeout_add_seconds(1, (GSourceFunc)set_label_time, current_time); gtk_label_set_text(GTK_LABEL(network_speed), "Network Speed:100M"); gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE); int n = gtk_notebook_page_num(GTK_NOTEBOOK(notebook), icon_view); //gtk_combo_box_set_model(GTK_COMBO_BOX(blog_access_permission), create_combo_box_tree_model()); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "private", "PRIVATE"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "public", "PUBLIC"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "password", "PASSWORD"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "friend", "FRIEND"); printf("n is %d\n", n); struct tm *time_ptr; time_t the_time; char *time_malloc; (void)time(&the_time); time_ptr = localtime(&the_time); time_malloc = malloc(sizeof(struct tm)); memset(time_malloc, 0, sizeof(struct tm)); sprintf(time_malloc, "%d/%d/%d/%d:%d:%d", 1900 + time_ptr->tm_year, time_ptr->tm_mon, time_ptr->tm_mday, time_ptr->tm_hour, time_ptr->tm_min, time_ptr->tm_sec); gtk_label_set_text(GTK_LABEL(current_time), time_malloc); post_blog_page = g_list_append(post_blog_page, post_blog_title_entry); post_blog_page = g_list_append(post_blog_page, post_blog_content_text_view); post_blog_page = g_list_append(post_blog_page, blog_access_permission); post_blog_page = g_list_append(post_blog_page, blog_password); //signal to connect to widget g_signal_connect(window, "delete-event", gtk_main_quit, NULL); g_signal_connect(GTK_BUTTON(get_access_token_button), "clicked", G_CALLBACK(get_access_token_button_clicked), NULL); g_signal_connect(GTK_ICON_VIEW(icon_view), "item-activated", G_CALLBACK(icon_view_item_select), notebook); g_signal_connect(GTK_BUTTON(home_button), "clicked", G_CALLBACK(home_button_clicked), notebook); g_signal_connect(GTK_BUTTON(access_token_ok_button), "clicked", G_CALLBACK(access_token_ok_button_clicked), access_token_entry); g_signal_connect(GTK_BUTTON(post_blog_ok_button), "clicked", G_CALLBACK(post_blog_ok_button_clicked), post_blog_page); //object unref g_object_unref(G_OBJECT(builder)); //show widget gtk_widget_show_all(window); gtk_main(); int i = 100; char *decode_string; /*CURL *curl; curl_global_init(CURL_GLOBAL_ALL); curl = curl_easy_init(); decode_string = curl_easy_unescape(curl, ACCESS_TOKEN, 0, &i); printf("origin url: %s\n", ACCESS_TOKEN); printf("new url: %s\n", decode_string); curl_easy_cleanup(curl);*/ //puts("enter access token\n"); //scanf("%s", accesstoken); //调用自己写的SDK xiaonei_gtk_get_blog_list(accesstoken); xiaonei_gtk_get_one_blog(accesstoken); return (EXIT_SUCCESS); }
void file_changed(GtkFileChooserButton *button, GtkLabel *label) { gchar *file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(button)); gtk_label_set_text(label, file); }
static void gimp_image_prop_view_update (GimpImagePropView *view) { GimpImage *image = view->image; GimpImageBaseType type; GimpPrecision precision; GimpUnit unit; gdouble unit_factor; gint unit_digits; const gchar *desc; gchar format_buf[32]; gchar buf[256]; gdouble xres; gdouble yres; gimp_image_get_resolution (image, &xres, &yres); /* pixel size */ g_snprintf (buf, sizeof (buf), ngettext ("%d × %d pixel", "%d × %d pixels", gimp_image_get_height (image)), gimp_image_get_width (image), gimp_image_get_height (image)); gtk_label_set_text (GTK_LABEL (view->pixel_size_label), buf); /* print size */ unit = gimp_get_default_unit (); unit_digits = gimp_unit_get_digits (unit); g_snprintf (format_buf, sizeof (format_buf), "%%.%df × %%.%df %s", unit_digits + 1, unit_digits + 1, gimp_unit_get_plural (unit)); g_snprintf (buf, sizeof (buf), format_buf, gimp_pixels_to_units (gimp_image_get_width (image), unit, xres), gimp_pixels_to_units (gimp_image_get_height (image), unit, yres)); gtk_label_set_text (GTK_LABEL (view->print_size_label), buf); /* resolution */ unit = gimp_image_get_unit (image); unit_factor = gimp_unit_get_factor (unit); g_snprintf (format_buf, sizeof (format_buf), _("pixels/%s"), gimp_unit_get_abbreviation (unit)); g_snprintf (buf, sizeof (buf), _("%g × %g %s"), xres / unit_factor, yres / unit_factor, unit == GIMP_UNIT_INCH ? _("ppi") : format_buf); gtk_label_set_text (GTK_LABEL (view->resolution_label), buf); /* color type */ type = gimp_image_get_base_type (image); gimp_enum_get_value (GIMP_TYPE_IMAGE_BASE_TYPE, type, NULL, NULL, &desc, NULL); switch (type) { case GIMP_RGB: case GIMP_GRAY: g_snprintf (buf, sizeof (buf), "%s", desc); break; case GIMP_INDEXED: g_snprintf (buf, sizeof (buf), "%s (%d %s)", desc, gimp_image_get_colormap_size (image), _("colors")); break; } gtk_label_set_text (GTK_LABEL (view->colorspace_label), buf); /* precision */ precision = gimp_image_get_precision (image); gimp_enum_get_value (GIMP_TYPE_PRECISION, precision, NULL, NULL, &desc, NULL); gtk_label_set_text (GTK_LABEL (view->precision_label), desc); /* size in memory */ gimp_image_prop_view_label_set_memsize (view->memsize_label, GIMP_OBJECT (image)); /* undo / redo */ gimp_image_prop_view_label_set_undo (view->undo_label, gimp_image_get_undo_stack (image)); gimp_image_prop_view_label_set_undo (view->redo_label, gimp_image_get_redo_stack (image)); /* number of layers */ g_snprintf (buf, sizeof (buf), "%d", gimp_image_get_width (image) * gimp_image_get_height (image)); gtk_label_set_text (GTK_LABEL (view->pixels_label), buf); /* number of layers */ g_snprintf (buf, sizeof (buf), "%d", gimp_image_get_n_layers (image)); gtk_label_set_text (GTK_LABEL (view->layers_label), buf); /* number of channels */ g_snprintf (buf, sizeof (buf), "%d", gimp_image_get_n_channels (image)); gtk_label_set_text (GTK_LABEL (view->channels_label), buf); /* number of vectors */ g_snprintf (buf, sizeof (buf), "%d", gimp_image_get_n_vectors (image)); gtk_label_set_text (GTK_LABEL (view->vectors_label), buf); }
void CLuaProgressDialog::CoreSetTitle(const char *title) { gtk_label_set_text(GTK_LABEL(m_pTitle), GetTranslation(title)); }
void dlg_prop (FrWindow *window) { DialogData *data; GtkWidget *ok_button; GtkWidget *help_button; GtkWidget *label_label; GtkWidget *label; char *s; goffset size, uncompressed_size; char *utf8_name; char *title_txt; double ratio; data = g_new (DialogData, 1); data->builder = _gtk_builder_new_from_file ("properties.ui"); if (data->builder == NULL) { g_free (data); return; } /* Get the widgets. */ data->dialog = _gtk_builder_get_widget (data->builder, "prop_dialog"); ok_button = _gtk_builder_get_widget (data->builder, "p_ok_button"); help_button = _gtk_builder_get_widget (data->builder, "p_help_button"); /* Set widgets data. */ label_label = _gtk_builder_get_widget (data->builder, "p_path_label_label"); /* Translators: after the colon there is a folder name. */ set_label (label_label, _("Location:")); label = _gtk_builder_get_widget (data->builder, "p_path_label"); s = remove_level_from_path (fr_window_get_archive_uri (window)); utf8_name = g_filename_display_name (s); gtk_label_set_text (GTK_LABEL (label), utf8_name); g_free (utf8_name); g_free (s); /**/ label_label = _gtk_builder_get_widget (data->builder, "p_name_label_label"); set_label (label_label, C_("File", "Name:")); label = _gtk_builder_get_widget (data->builder, "p_name_label"); utf8_name = g_uri_display_basename (fr_window_get_archive_uri (window)); gtk_label_set_text (GTK_LABEL (label), utf8_name); title_txt = g_strdup_printf (_("%s Properties"), utf8_name); gtk_window_set_title (GTK_WINDOW (data->dialog), title_txt); g_free (title_txt); g_free (utf8_name); /**/ label_label = _gtk_builder_get_widget (data->builder, "p_date_label_label"); set_label (label_label, _("Last modified:")); label = _gtk_builder_get_widget (data->builder, "p_date_label"); s = get_time_string (get_file_mtime (fr_window_get_archive_uri (window))); gtk_label_set_text (GTK_LABEL (label), s); g_free (s); /**/ label_label = _gtk_builder_get_widget (data->builder, "p_size_label_label"); set_label (label_label, _("Archive size:")); label = _gtk_builder_get_widget (data->builder, "p_size_label"); size = get_file_size (fr_window_get_archive_uri (window)); s = g_format_size (size); gtk_label_set_text (GTK_LABEL (label), s); g_free (s); /**/ label_label = _gtk_builder_get_widget (data->builder, "p_uncomp_size_label_label"); set_label (label_label, _("Content size:")); uncompressed_size = 0; if (fr_window_archive_is_present (window)) { int i; for (i = 0; i < window->archive->command->files->len; i++) { FileData *fd = g_ptr_array_index (window->archive->command->files, i); uncompressed_size += fd->size; } } label = _gtk_builder_get_widget (data->builder, "p_uncomp_size_label"); s = g_format_size (uncompressed_size); gtk_label_set_text (GTK_LABEL (label), s); g_free (s); /**/ label_label = _gtk_builder_get_widget (data->builder, "p_cratio_label_label"); set_label (label_label, _("Compression ratio:")); label = _gtk_builder_get_widget (data->builder, "p_cratio_label"); if (uncompressed_size != 0) ratio = (double) uncompressed_size / size; else ratio = 0.0; s = g_strdup_printf ("%0.2f", ratio); gtk_label_set_text (GTK_LABEL (label), s); g_free (s); /**/ label_label = _gtk_builder_get_widget (data->builder, "p_files_label_label"); set_label (label_label, _("Number of files:")); label = _gtk_builder_get_widget (data->builder, "p_files_label"); s = g_strdup_printf ("%d", window->archive->command->n_regular_files); gtk_label_set_text (GTK_LABEL (label), s); g_free (s); /* Set the signals handlers. */ g_signal_connect (G_OBJECT (data->dialog), "destroy", G_CALLBACK (destroy_cb), data); g_signal_connect_swapped (G_OBJECT (ok_button), "clicked", G_CALLBACK (gtk_widget_destroy), G_OBJECT (data->dialog)); g_signal_connect (G_OBJECT (help_button), "clicked", G_CALLBACK (help_cb), data); /* Run dialog. */ gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (window)); gtk_window_set_modal (GTK_WINDOW (data->dialog), TRUE); gtk_widget_show (data->dialog); }
static void CappletActivePluginsSelectionChanged (GtkTreeSelection * selection, MatekbdIndicatorPluginsCapplet * gipc) { GtkWidget *activePlugins = CappletGetUiWidget (gipc, "activePlugins"); GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (activePlugins)); GtkTreeIter selectedIter; gboolean isAnythingSelected = FALSE; gboolean isFirstSelected = FALSE; gboolean isLastSelected = FALSE; gboolean hasConfigurationUi = FALSE; GtkWidget *btnRemove = CappletGetUiWidget (gipc, "btnRemove"); GtkWidget *btnUp = CappletGetUiWidget (gipc, "btnUp"); GtkWidget *btnDown = CappletGetUiWidget (gipc, "btnDown"); GtkWidget *btnProperties = CappletGetUiWidget (gipc, "btnProperties"); GtkWidget *lblDescription = CappletGetUiWidget (gipc, "lblDescription"); gtk_label_set_text (GTK_LABEL (lblDescription), g_strconcat ("<small><i>", _("No description."), "</i></small>", NULL)); gtk_label_set_use_markup (GTK_LABEL (lblDescription), TRUE); if (gtk_tree_selection_get_selected (selection, NULL, &selectedIter)) { int counter = gtk_tree_model_iter_n_children (model, NULL); GtkTreePath *treePath = gtk_tree_model_get_path (model, &selectedIter); gint *indices = gtk_tree_path_get_indices (treePath); char *fullPath = CappletGetSelectedActivePluginPath (gipc); const MatekbdIndicatorPlugin *plugin = matekbd_indicator_plugin_manager_get_plugin (&gipc-> plugin_manager, fullPath); isAnythingSelected = TRUE; isFirstSelected = indices[0] == 0; isLastSelected = indices[0] == counter - 1; if (plugin != NULL) { hasConfigurationUi = (plugin->configure_properties_callback != NULL); gtk_label_set_text (GTK_LABEL (lblDescription), g_strconcat ("<small><i>", plugin-> description, "</i></small>", NULL)); gtk_label_set_use_markup (GTK_LABEL (lblDescription), TRUE); } g_free (fullPath); gtk_tree_path_free (treePath); } gtk_widget_set_sensitive (btnRemove, isAnythingSelected); gtk_widget_set_sensitive (btnUp, isAnythingSelected && !isFirstSelected); gtk_widget_set_sensitive (btnDown, isAnythingSelected && !isLastSelected); gtk_widget_set_sensitive (btnProperties, isAnythingSelected && hasConfigurationUi); }
void vmat_create_list (class vmat_data *data) { class iceb_gdite_data gdite; iceb_gdite(&gdite,0,data->window); GtkListStore *model=NULL; GtkTreeIter iter; char strsql[400]; int kolstr=0; SQLCURSOR cur; SQL_str row; printf("vmat_create_list %d\n",data->snanomer); data->kl_shift=0; //0-отжата 1-нажата gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); if(data->treeview != NULL) gtk_widget_destroy(data->treeview); data->treeview = gtk_tree_view_new(); gtk_container_add (GTK_CONTAINER (data->sw), data->treeview); g_signal_connect(data->treeview,"row_activated",G_CALLBACK(vmat_v_row),data); GtkTreeSelection *selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(data->treeview)); gtk_tree_selection_set_mode(selection,GTK_SELECTION_SINGLE); g_signal_connect(selection,"changed",G_CALLBACK(vmat_vibor),data); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (data->treeview), TRUE); //Устанавливаются полоски при отображении списка gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->treeview)),GTK_SELECTION_SINGLE); model = gtk_list_store_new (NUM_COLUMNS+1, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); //gtk_list_store_clear(model); if(data->metkarr == 0) sprintf(strsql,"select kodm,naimat,ei,cenapr from Material where kodgr=%d \ and cenapr != 0. and ei != '' order by naimat asc",data->kodgr); if(data->metkarr == 1) sprintf(strsql,"select kodus,naius,ei,cena from Uslugi where kodgr=%d \ and cena != 0. and ei != '' order by naius asc",data->kodgr); if((kolstr=cur.make_cursor(&bd,strsql)) < 0) { iceb_msql_error(&bd,gettext("Ошибка создания курсора !"),strsql,data->window); return; } //gtk_list_store_clear(model); iceb_u_str s1; iceb_u_str s2; iceb_u_str s3; iceb_u_str s4; float kolstr1=0.; data->kolzap=0; while(cur.read_cursor(&row) != 0) { iceb_pbar(gdite.bar,kolstr,++kolstr1); // printf("%s %s %s %s\n",row[0],row[1],row[2],row[3]); //код s1.new_plus(row[0]); //наименование s2.new_plus(iceb_u_toutf(row[1])); //единица измерения s3.new_plus(iceb_u_toutf(row[2])); //цена sprintf(strsql,"%.2f",atof(row[3])); s4.new_plus(strsql); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, COL_KOD,s1.ravno(), COL_NAIM,s2.ravno(), COL_EI,s3.ravno(), COL_CENA,s4.ravno(), NUM_COLUMNS,data->kolzap, -1); data->kolzap++; } gtk_tree_view_set_model (GTK_TREE_VIEW(data-> treeview),GTK_TREE_MODEL (model)); g_object_unref (GTK_TREE_MODEL (model)); vmat_add_columns (GTK_TREE_VIEW (data->treeview)); if(data->kolzap == 0) { gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK2]),FALSE);//Недоступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK_VVERH]),FALSE);//Недоступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK_VNIZ]),FALSE);//Недоступна } else { gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK2]),TRUE);//Доступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK_VVERH]),TRUE);//Доступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK_VNIZ]),TRUE);//Доступна } gtk_widget_show (data->treeview); gtk_widget_show (data->sw); if(data->kolzap > 0) l_vmat_setstr(data); //стать на нужную строку iceb_u_str stroka; iceb_u_str zagolov; sprintf(strsql,"%s:%d %s",gettext("Группа"),data->kodgr,data->naigr.ravno()); zagolov.plus_ps(strsql); zagolov.plus(gettext("Выберите нужную запись")); sprintf(strsql," %s:%d",gettext("Количество записей"),data->kolzap); zagolov.plus(strsql); gtk_label_set_text(GTK_LABEL(data->label_kolstr),zagolov.ravno_toutf()); gtk_widget_show(data->label_kolstr); gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR)); }
/** Search throught the existing glyphs , if not present create it and append the text to decodedString */ ReplyType glyphToText(admGlyph *glyph) { admGlyph *cand; //printf("2t: %d x %d\n",glyph->width,glyph->height); if(glyph->width<2 && glyph->height<2) { delete glyph; return ReplyOk; } cand=searchGlyph(&head,glyph); if(!cand) // New glyph { char *string; // Draw it displaySmall(glyph); gtk_label_set_text(GTK_LABEL(WID(labelText)),decodedString); gtk_editable_delete_text(GTK_EDITABLE(WID(entry)), 0,-1); //gtk_widget_set_sensitive(WID(buttonAccept),1); //gtk_widget_set_sensitive(WID(buttonSkip),1); //gtk_widget_set_sensitive(WID(entryEntry),1); gtk_widget_grab_focus (WID(entry)); gtk_widget_grab_default (WID(buttonOk)); //printf("i\n"); switch(gtk_dialog_run(GTK_DIALOG(dialog))) { case actionIgnore: glyph->code=NULL; insertInGlyphTree(&head,glyph); nbGlyphs++; break; case actionCalibrate: return ReplyCalibrate; case actionAccept: string =gtk_editable_get_chars(GTK_EDITABLE (WID(entry)), 0, -1); if(string&& strlen(string)) { glyph->code=ADM_strdup(string); insertInGlyphTree(&head,glyph); //printf("New glyph:%s\n",glyph->code); strcat(decodedString,glyph->code); nbGlyphs++; } else delete glyph; break; case actionSkip: //SKIP return ReplySkip; break; case actionSkipAll: return ReplySkipAll; break; case GTK_RESPONSE_CLOSE: if(GUI_Question(_("Sure ?"))) return ReplyClose; break; // Abort } gtk_editable_delete_text(GTK_EDITABLE(WID(entry)), 0,-1); //gtk_widget_set_sensitive(WID(buttonAccept),0); //gtk_widget_set_sensitive(WID(buttonSkip),0); //gtk_widget_set_sensitive(WID(entryEntry),0); } else { //printf("Glyph known :%s \n",cand->code); if(cand->code) strcat(decodedString,cand->code); delete glyph; } return ReplyOk; }
/* download_progress_cb(WebKitDownload *) {{{*/ static void download_progress_cb(WebKitDownload *download, GParamSpec *p, DwbDownloadStatus *status) { /* Update at most four times a second */ gint64 time = g_get_monotonic_time(); static double speed = 0; static guint remaining = 0; if (time - status->time > 250000) { GList *l = download_get_download_label(download); DwbDownload *label = l->data; double elapsed = webkit_download_get_elapsed_time(download); double progress = webkit_download_get_progress(download); double total_size = (double)webkit_download_get_total_size(download) / 0x100000; if (time - status->speedtime > 1000000) { speed = ((progress - status->progress)*total_size) * 1000000 / (time - status->speedtime); status->speedtime = time; status->progress = progress; remaining = (guint)(elapsed / progress - elapsed); } double current_size = (double)webkit_download_get_current_size(download) / 0x100000; char buffer[128] = {0}; const char *format = speed > 1 ? "[%.1fM/s|%d:%02d|%2d%%|%.3f/%.3f]" : "[%3.1fK/s|%d:%02d|%2d%%|%.3f/%.3f]"; snprintf(buffer, sizeof(buffer), format, speed > 1 ? speed : speed*1024, remaining/60, remaining%60, (int)(progress*100), current_size, total_size); gtk_label_set_text(GTK_LABEL(label->rlabel), buffer); #if _HAS_GTK3 gdouble red, green, blue, alpha; #else guint red, green, blue; #endif red = ((progress) * dwb.color.download_end.red + (1-progress) * dwb.color.download_start.red); green = ((progress) * dwb.color.download_end.green + (1-progress) * dwb.color.download_start.green); blue = ((progress) * dwb.color.download_end.blue + (1-progress) * dwb.color.download_start.blue); #if _HAS_GTK3 alpha = ((progress) * dwb.color.download_end.alpha + (1-progress) * dwb.color.download_start.alpha); if (blue != status->blue || red != status->red || green != status->green || alpha != status->alpha) { #else if (blue != status->blue || red != status->red || green != status->green) { #endif DwbColor gradient = { .red = red, .green = green, .blue = blue, #if _HAS_GTK3 .alpha = alpha #endif }; DWB_WIDGET_OVERRIDE_BACKGROUND(label->event, GTK_STATE_NORMAL, &gradient); } status->blue = blue; status->red = red; status->green = green; #if _HAS_GTK3 status->alpha = alpha; #endif status->time = time; }
static void enroll_fingerprints (GtkWindow *parent, GtkWidget *enable, GtkWidget *disable) { DBusGProxy *device, *p; GHashTable *props; GtkBuilder *dialog; EnrollData *data; GtkWidget *ass; char *msg; device = NULL; if (manager == NULL) { create_manager (); if (manager != NULL) device = get_first_device (); } else { device = get_first_device (); } if (manager == NULL || device == NULL) { GtkWidget *d; d = get_error_dialog (_("Could not access any fingerprint readers"), _("Please contact your system administrator for help."), parent); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (d); return; } data = g_new0 (EnrollData, 1); data->device = device; data->enable = enable; data->disable = disable; /* Get some details about the device */ p = dbus_g_proxy_new_from_proxy (device, "org.freedesktop.DBus.Properties", NULL); if (dbus_g_proxy_call (p, "GetAll", NULL, G_TYPE_STRING, "net.reactivated.Fprint.Device", G_TYPE_INVALID, dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &props, G_TYPE_INVALID)) { const char *scan_type; data->name = g_value_dup_string (g_hash_table_lookup (props, "name")); scan_type = g_value_dup_string (g_hash_table_lookup (props, "scan-type")); if (g_str_equal (scan_type, "swipe")) data->is_swipe = TRUE; g_hash_table_destroy (props); } g_object_unref (p); dialog = gtk_builder_new (); gtk_builder_add_from_file (dialog, MATECC_UI_DIR "/mate-about-me-fingerprint.ui", NULL); data->dialog = dialog; ass = WID ("assistant"); gtk_window_set_title (GTK_WINDOW (ass), _("Enable Fingerprint Login")); gtk_window_set_transient_for (GTK_WINDOW (ass), parent); gtk_window_set_position (GTK_WINDOW (ass), GTK_WIN_POS_CENTER_ON_PARENT); g_signal_connect (G_OBJECT (ass), "cancel", G_CALLBACK (assistant_cancelled), data); g_signal_connect (G_OBJECT (ass), "close", G_CALLBACK (assistant_cancelled), data); g_signal_connect (G_OBJECT (ass), "prepare", G_CALLBACK (assistant_prepare), data); /* Page 1 */ gtk_combo_box_set_active (GTK_COMBO_BOX (WID ("finger_combobox")), 0); g_signal_connect (G_OBJECT (WID ("radiobutton1")), "toggled", G_CALLBACK (finger_radio_button_toggled), data); g_signal_connect (G_OBJECT (WID ("radiobutton2")), "toggled", G_CALLBACK (finger_radio_button_toggled), data); g_signal_connect (G_OBJECT (WID ("radiobutton3")), "toggled", G_CALLBACK (finger_radio_button_toggled), data); g_signal_connect (G_OBJECT (WID ("finger_combobox")), "changed", G_CALLBACK (finger_combobox_changed), data); data->finger = selected_finger (dialog); g_object_set_data (G_OBJECT (WID("page1")), "name", "intro"); /* translators: * The variable is the name of the device, for example: * "To enable fingerprint login, you need to save one of your fingerprints, using the * 'Digital Persona U.are.U 4000/4000B' device." */ msg = g_strdup_printf (_("To enable fingerprint login, you need to save one of your fingerprints, using the '%s' device."), data->name); gtk_label_set_text (GTK_LABEL (WID("intro-label")), msg); g_free (msg); gtk_assistant_set_page_complete (GTK_ASSISTANT (ass), WID("page1"), TRUE); /* Page 2 */ if (data->is_swipe != FALSE) gtk_assistant_set_page_title (GTK_ASSISTANT (ass), WID("page2"), _("Swipe finger on reader")); else gtk_assistant_set_page_title (GTK_ASSISTANT (ass), WID("page2"), _("Place finger on reader")); g_object_set_data (G_OBJECT (WID("page2")), "name", "enroll"); msg = g_strdup_printf (TR(finger_str_to_msg (data->finger, data->is_swipe)), data->name); gtk_label_set_text (GTK_LABEL (WID("enroll-label")), msg); g_free (msg); /* Page 3 */ g_object_set_data (G_OBJECT (WID("page3")), "name", "summary"); data->ass = ass; gtk_widget_show_all (ass); }
/** * cb_dialog_apply_clicked: * @button: * @state: * * Close (destroy) the dialog **/ static void cb_dialog_apply_clicked (G_GNUC_UNUSED GtkWidget *button, GoalSeekState *state) { char *status_str; GoalSeekStatus status; GnmValue *target; GnmRangeRef const *r; GOFormat *format; if (state->warning_dialog != NULL) gtk_widget_destroy (state->warning_dialog); /* set up source */ target = gnm_expr_entry_parse_as_value (state->set_cell_entry, state->sheet); if (target == NULL) { go_gtk_notice_nonmodal_dialog (GTK_WINDOW(state->dialog), &(state->warning_dialog), GTK_MESSAGE_ERROR, _("You should introduce a valid cell " "name in 'Set Cell:'!")); gnm_expr_entry_grab_focus (state->set_cell_entry, TRUE); return; } r = &target->v_range.cell; state->set_cell = sheet_cell_get (r->a.sheet, r->a.col, r->a.row); value_release (target); if (state->set_cell == NULL || !gnm_cell_has_expr (state->set_cell)) { go_gtk_notice_nonmodal_dialog (GTK_WINDOW(state->dialog), &(state->warning_dialog), GTK_MESSAGE_ERROR, _("The cell named in 'Set Cell:' " "must contain a formula!")); gnm_expr_entry_grab_focus (state->set_cell_entry, TRUE); return; } /* set up source */ target = gnm_expr_entry_parse_as_value (state->change_cell_entry, state->sheet); if (target == NULL) { go_gtk_notice_nonmodal_dialog (GTK_WINDOW(state->dialog), &(state->warning_dialog), GTK_MESSAGE_ERROR, _("You should introduce a valid cell " "name in 'By Changing Cell:'!")); gnm_expr_entry_grab_focus (state->change_cell_entry, TRUE); return; } r = &target->v_range.cell; state->change_cell = sheet_cell_fetch (r->a.sheet, r->a.col, r->a.row); value_release (target); if (gnm_cell_has_expr (state->change_cell)) { go_gtk_notice_nonmodal_dialog (GTK_WINDOW(state->dialog), &(state->warning_dialog), GTK_MESSAGE_ERROR, _("The cell named in 'By changing cell' " "must not contain a formula.")); gnm_expr_entry_grab_focus (state->change_cell_entry, TRUE); return; } format = gnm_style_get_format (gnm_cell_get_style (state->set_cell)); if (entry_to_float_with_format (GTK_ENTRY(state->to_value_entry), &state->target_value, TRUE, format)){ go_gtk_notice_nonmodal_dialog (GTK_WINDOW(state->dialog), &(state->warning_dialog), GTK_MESSAGE_ERROR, _("The value given in 'To Value:' " "is not valid.")); focus_on_entry (GTK_ENTRY(state->to_value_entry)); return; } format = gnm_style_get_format (gnm_cell_get_style (state->change_cell)); if (entry_to_float_with_format (GTK_ENTRY(state->at_least_entry), &state->xmin, TRUE, format)) { state->xmin = -max_range_val; gtk_entry_set_text (GTK_ENTRY (state->at_least_entry), ""); } if (entry_to_float_with_format (GTK_ENTRY(state->at_most_entry), &state->xmax, TRUE, format)) { state->xmax = +max_range_val; gtk_entry_set_text (GTK_ENTRY (state->at_most_entry), ""); } if ((state->old_cell != NULL) && (state->old_value != NULL)) { sheet_cell_set_value (state->old_cell, state->old_value); workbook_recalc (state->wb); state->old_value = NULL; } state->old_cell = state->change_cell; state->old_value = value_dup (state->change_cell->value); status = gnumeric_goal_seek (state); switch (status) { case GOAL_SEEK_OK: { const char *actual_str; const char *solution_str; GOFormat *format = go_format_general (); GnmValue *error_value = value_new_float (state->target_value - value_get_as_float (state->set_cell->value)); char *target_str = format_value (format, error_value, NULL, -1, workbook_date_conv (state->wb)); gtk_label_set_text (GTK_LABEL (state->target_value_label), target_str); g_free (target_str); value_release (error_value); status_str = g_strdup_printf (_("Goal seeking with cell %s found a solution."), cell_name (state->set_cell)); gtk_label_set_text (GTK_LABEL (state->result_label), status_str); g_free (status_str); /* FIXME? Do a format? */ actual_str = state->set_cell->value ? value_peek_string (state->set_cell->value) : ""; gtk_label_set_text (GTK_LABEL (state->current_value_label), actual_str); solution_str = state->change_cell->value ? value_peek_string (state->change_cell->value) : ""; gtk_label_set_text (GTK_LABEL (state->solution_label), solution_str); break; } default: status_str = g_strdup_printf (_("Goal seeking with cell %s did not find a solution."), cell_name (state->set_cell)); gtk_label_set_text (GTK_LABEL (state->result_label), status_str); g_free (status_str); gtk_label_set_text (GTK_LABEL (state->current_value_label), ""); gtk_label_set_text (GTK_LABEL (state->solution_label), ""); gtk_label_set_text (GTK_LABEL (state->target_value_label), ""); break; } state->cancelled = FALSE; gtk_widget_show (state->result_table); return; }