KiCad PCB EDA Suite
base_units.cpp File Reference

Code to handle objects that require both schematic and board internal units. More...

#include <base_struct.h>
#include <base_units.h>
#include <common.h>
#include <math/util.h>
#include <macros.h>
#include <title_block.h>
#include "libeval/numeric_evaluator.h"

Go to the source code of this file.

Functions

std::string Double2Str (double aValue)
 Helper function Double2Str to print a float number without using scientific notation and no trailing 0 We want to avoid scientific notation in S-expr files (not easy to read) for floating numbers. More...
 
double To_User_Unit (EDA_UNITS aUnit, double aValue, bool aUseMils)
 Function To_User_Unit convert aValue in internal units to the appropriate user units defined by aUnit. More...
 
wxString MessageTextFromValue (EDA_UNITS aUnits, int aValue, bool aUseMils)
 
wxString MessageTextFromValue (EDA_UNITS aUnits, long long int aValue, bool aUseMils)
 
wxString MessageTextFromValue (EDA_UNITS aUnits, double aValue, bool aUseMils)
 Function MessageTextFromValue is a helper to convert the double length aValue to a string in inches, millimeters, or unscaled units. More...
 
void StripTrailingZeros (wxString &aStringValue, unsigned aTrailingZeroAllowed)
 Function StripTrailingZeros Remove trailing 0 from a string containing a converted float number. More...
 
wxString StringFromValue (EDA_UNITS aUnits, double aValue, bool aAddUnitSymbol, bool aUseMils)
 Function StringFromValue returns the string from aValue according to units (inch, mm ...) for display, and the initial unit for value. More...
 
double From_User_Unit (EDA_UNITS aUnits, double aValue, bool aUseMils)
 Return in internal units the value "val" given in a real unit such as "in", "mm" or "deg". More...
 
double DoubleValueFromString (EDA_UNITS aUnits, const wxString &aTextValue, bool aUseMils)
 Function DoubleValueFromString converts aTextValue to a double. More...
 
void FetchUnitsFromString (const wxString &aTextValue, EDA_UNITS &aUnits, bool &aUseMils)
 Function FetchUnitsFromString writes any unit info found in the string to aUnits and aUseMils. More...
 
long long int ValueFromString (EDA_UNITS aUnits, const wxString &aTextValue, bool aUseMils)
 Function ValueFromString converts aTextValue in aUnits to internal units used by the application. More...
 
wxString AngleToStringDegrees (double aAngle)
 Function AngleToStringDegrees is a helper to convert the double aAngle (in internal unit) to a string in degrees. More...
 
wxString GetAbbreviatedUnitsLabel (EDA_UNITS aUnit, bool aUseMils)
 Get the units string for a given units type. More...
 
std::string FormatInternalUnits (int aValue)
 Function FormatInternalUnits converts aValue from internal units to a string appropriate for writing to file. More...
 
std::string FormatAngle (double aAngle)
 Function FormatAngle converts aAngle from board units to a string appropriate for writing to file. More...
 
std::string FormatInternalUnits (const wxPoint &aPoint)
 
std::string FormatInternalUnits (const VECTOR2I &aPoint)
 
std::string FormatInternalUnits (const wxSize &aSize)
 

Detailed Description

Code to handle objects that require both schematic and board internal units.

Author
Wayne Stambaugh stamb.nosp@m.augh.nosp@m.w@ver.nosp@m.izon.nosp@m..net
Note
This file is an ugly hack to solve the problem of formatting the base units for either schematics or boards in objects that are include in both domains. At some point in the future. This code should be rolled back into the appropriate object and build with the correct internal unit formatting depending on the application.

Definition in file base_units.cpp.

Function Documentation

◆ AngleToStringDegrees()

wxString AngleToStringDegrees ( double  aAngle)

Function AngleToStringDegrees is a helper to convert the double aAngle (in internal unit) to a string in degrees.

Definition at line 441 of file base_units.cpp.

442 {
443  wxString text;
444 
445  text.Printf( wxT( "%.3f" ), aAngle/10.0 );
446  StripTrailingZeros( text, 1 );
447 
448  return text;
449 }
void StripTrailingZeros(wxString &aStringValue, unsigned aTrailingZeroAllowed)
Function StripTrailingZeros Remove trailing 0 from a string containing a converted float number.
Definition: base_units.cpp:187

References StripTrailingZeros().

Referenced by PANEL_PCBNEW_SETTINGS::TransferDataToWindow().

◆ Double2Str()

std::string Double2Str ( double  aValue)

Helper function Double2Str to print a float number without using scientific notation and no trailing 0 We want to avoid scientific notation in S-expr files (not easy to read) for floating numbers.

So we cannot always just use the g or the f format to print a fp number this helper function uses the f format when needed, or g when f is not well working and then removes trailing 0

Definition at line 65 of file base_units.cpp.

66 {
67  char buf[50];
68  int len;
69 
70  if( aValue != 0.0 && fabs( aValue ) <= 0.0001 )
71  {
72  // For these small values, %f works fine,
73  // and %g gives an exponent
74  len = sprintf( buf, "%.16f", aValue );
75 
76  while( --len > 0 && buf[len] == '0' )
77  buf[len] = '\0';
78 
79  if( buf[len] == '.' )
80  buf[len] = '\0';
81  else
82  ++len;
83  }
84  else
85  {
86  // For these values, %g works fine, and sometimes %f
87  // gives a bad value (try aValue = 1.222222222222, with %.16f format!)
88  len = sprintf( buf, "%.16g", aValue );
89  }
90 
91  return std::string( buf, len );
92 }

Referenced by GBR_TO_PCB_EXPORTER::export_flashed_copper_item(), PCB_IO::format(), BOARD_STACKUP::FormatBoardStackup(), PCB_IO::formatSetup(), GBR_TO_PCB_EXPORTER::writeCopperLineItem(), GBR_TO_PCB_EXPORTER::writePcbLineItem(), GBR_TO_PCB_EXPORTER::writePcbPolygonItem(), and GBR_TO_PCB_EXPORTER::writePcbZoneItem().

◆ DoubleValueFromString()

double DoubleValueFromString ( EDA_UNITS  aUnits,
const wxString &  aTextValue,
bool  aUseMils = false 
)

Function DoubleValueFromString converts aTextValue to a double.

Parameters
aUnitsThe units of aTextValue.
aTextValueA reference to a wxString object containing the string to convert.
aUseMilsIndicates mils should be used for imperial units (inches).
Returns
A double representing that value in internal units

Definition at line 316 of file base_units.cpp.

317 {
318  double value;
319  double dtmp = 0;
320 
321  // Acquire the 'right' decimal point separator
322  const struct lconv* lc = localeconv();
323 
324  wxChar decimal_point = lc->decimal_point[0];
325  wxString buf( aTextValue.Strip( wxString::both ) );
326 
327  // Convert the period in decimal point
328  buf.Replace( wxT( "." ), wxString( decimal_point, 1 ) );
329 
330  // Find the end of the numeric part
331  unsigned brk_point = 0;
332 
333  while( brk_point < buf.Len() )
334  {
335  wxChar ch = buf[brk_point];
336 
337  if( !( (ch >= '0' && ch <='9') || (ch == decimal_point) || (ch == '-') || (ch == '+') ) )
338  {
339  break;
340  }
341 
342  ++brk_point;
343  }
344 
345  // Extract the numeric part
346  buf.Left( brk_point );
347 
348  buf.ToDouble( &dtmp );
349 
350  // Check the optional unit designator (2 ch significant)
351  wxString unit( buf.Mid( brk_point ).Strip( wxString::leading ).Left( 2 ).Lower() );
352 
353  if( aUnits == EDA_UNITS::INCHES || aUnits == EDA_UNITS::MILLIMETRES )
354  {
355  if( unit == wxT( "in" ) || unit == wxT( "\"" ) )
356  {
357  aUnits = EDA_UNITS::INCHES;
358  aUseMils = false;
359  }
360  else if( unit == wxT( "mm" ) )
361  {
362  aUnits = EDA_UNITS::MILLIMETRES;
363  }
364  else if( unit == wxT( "mi" ) || unit == wxT( "th" ) ) // "mils" or "thou"
365  {
366  aUnits = EDA_UNITS::INCHES;
367  aUseMils = true;
368  }
369  else if( unit == "oz" ) // 1 oz = 1.37 mils
370  {
371  aUnits = EDA_UNITS::INCHES;
372  aUseMils = true;
373  dtmp *= 1.37;
374  }
375  }
376  else if( aUnits == EDA_UNITS::DEGREES )
377  {
378  if( unit == wxT( "ra" ) ) // Radians
379  {
380  dtmp *= 180.0f / M_PI;
381  }
382  }
383 
384  value = From_User_Unit( aUnits, dtmp, aUseMils );
385 
386  return value;
387 }
double From_User_Unit(EDA_UNITS aUnits, double aValue, bool aUseMils)
Return in internal units the value "val" given in a real unit such as "in", "mm" or "deg".
Definition: base_units.cpp:291

References DEGREES, From_User_Unit(), INCHES, and MILLIMETRES.

Referenced by PANEL_PREV_3D::doIncrementOffset(), PANEL_PREV_3D::doIncrementRotation(), PANEL_PREV_3D::doIncrementScale(), DIALOG_IMPORT_GFX::getPCBdefaultLineWidthMM(), DIALOG_EXPORT_STEP::GetXOrg(), DIALOG_EXPORT_IDF3::GetXRef(), DIALOG_EXPORT_3DFILE::GetXRef(), DIALOG_EXPORT_STEP::GetYOrg(), DIALOG_EXPORT_IDF3::GetYRef(), DIALOG_EXPORT_3DFILE::GetYRef(), PANEL_PREV_3D::onMouseWheelOffset(), PANEL_PREV_3D::onMouseWheelRot(), PANEL_PREV_3D::onMouseWheelScale(), rotationFromString(), TEXT_MOD_GRID_TABLE::SetValue(), DIALOG_IMPORT_GFX::TransferDataFromWindow(), DIALOG_CREATE_ARRAY::TransferDataFromWindow(), DIALOG_PAD_PRIMITIVES_TRANSFORM::Transform(), PANEL_PREV_3D::updateOrientation(), DIALOG_IMPORT_GFX::updatePcbImportOffsets_mm(), and ValueFromString().

◆ FetchUnitsFromString()

void FetchUnitsFromString ( const wxString &  aTextValue,
EDA_UNITS aUnits,
bool &  aUseMils 
)

Function FetchUnitsFromString writes any unit info found in the string to aUnits and aUseMils.

Definition at line 390 of file base_units.cpp.

391 {
392  wxString buf( aTextValue.Strip( wxString::both ) );
393  unsigned brk_point = 0;
394 
395  while( brk_point < buf.Len() )
396  {
397  wxChar c = buf[brk_point];
398 
399  if( !( (c >= '0' && c <='9') || (c == '.') || (c == ',') || (c == '-') || (c == '+') ) )
400  break;
401 
402  ++brk_point;
403  }
404 
405  // Check the unit designator (2 ch significant)
406  wxString unit( buf.Mid( brk_point ).Strip( wxString::leading ).Left( 2 ).Lower() );
407 
408  if( unit == wxT( "in" ) || unit == wxT( "\"" ) )
409  {
410  aUnits = EDA_UNITS::INCHES;
411  aUseMils = false;
412  }
413  else if( unit == wxT( "mm" ) )
414  {
415  aUnits = EDA_UNITS::MILLIMETRES;
416  }
417  else if( unit == wxT( "mi" ) || unit == wxT( "th" ) ) // "mils" or "thou"
418  {
419  aUnits = EDA_UNITS::INCHES;
420  aUseMils = true;
421  }
422  else if( unit == wxT( "de" ) || unit == wxT( "ra" ) ) // "deg" or "rad"
423  {
424  aUnits = EDA_UNITS::DEGREES;
425  }
426 }

References DEGREES, INCHES, and MILLIMETRES.

Referenced by DIALOG_TEXT_PROPERTIES::OnDimensionTextChange(), and PCB_PARSER::parseDIMENSION().

◆ FormatAngle()

std::string FormatAngle ( double  aAngle)

Function FormatAngle converts aAngle from board units to a string appropriate for writing to file.

Note
Internal angles for board items can be either degrees or tenths of degree on how KiCad is built.
Parameters
aAngleA angle value to convert.
Returns
A std::string object containing the converted angle.

Definition at line 513 of file base_units.cpp.

514 {
515  char temp[50];
516  int len;
517 
518  len = snprintf( temp, sizeof(temp), "%.10g", aAngle / 10.0 );
519 
520  return std::string( temp, len );
521 }

Referenced by DIALOG_PAD_PROPERTIES::displayPrimitivesList(), and PCB_IO::format().

◆ FormatInternalUnits() [1/4]

std::string FormatInternalUnits ( int  aValue)

Function FormatInternalUnits converts aValue from internal units to a string appropriate for writing to file.

Note
Internal units for board items can be either deci-mils or nanometers depending on how KiCad is built.
Parameters
aValueA coordinate value to convert.
Returns
A std::string object containing the converted value.

Definition at line 480 of file base_units.cpp.

481 {
482  char buf[50];
483  double engUnits = aValue;
484  int len;
485 
486 #ifndef EESCHEMA
487  engUnits /= IU_PER_MM;
488 #endif
489 
490  if( engUnits != 0.0 && fabs( engUnits ) <= 0.0001 )
491  {
492  len = snprintf( buf, sizeof(buf), "%.10f", engUnits );
493 
494  while( --len > 0 && buf[len] == '0' )
495  buf[len] = '\0';
496 
497 #ifndef EESCHEMA
498  if( buf[len] == '.' )
499  buf[len] = '\0';
500  else
501 #endif
502  ++len;
503  }
504  else
505  {
506  len = snprintf( buf, sizeof(buf), "%.10g", engUnits );
507  }
508 
509  return std::string( buf, len );
510 }

Referenced by BOOST_AUTO_TEST_CASE(), NETCLASS::Format(), PCB_IO::format(), EDA_TEXT::Format(), BOARD_STACKUP::FormatBoardStackup(), PCB_IO::formatDefaults(), PCB_IO::formatGeneral(), FormatInternalUnits(), and PCB_IO::formatSetup().

◆ FormatInternalUnits() [2/4]

std::string FormatInternalUnits ( const wxPoint aPoint)

Definition at line 524 of file base_units.cpp.

525 {
526  return FormatInternalUnits( aPoint.x ) + " " + FormatInternalUnits( aPoint.y );
527 }
std::string FormatInternalUnits(int aValue)
Function FormatInternalUnits converts aValue from internal units to a string appropriate for writing ...
Definition: base_units.cpp:480

References FormatInternalUnits(), wxPoint::x, and wxPoint::y.

◆ FormatInternalUnits() [3/4]

std::string FormatInternalUnits ( const VECTOR2I aPoint)

Definition at line 530 of file base_units.cpp.

531 {
532  return FormatInternalUnits( aPoint.x ) + " " + FormatInternalUnits( aPoint.y );
533 }
std::string FormatInternalUnits(int aValue)
Function FormatInternalUnits converts aValue from internal units to a string appropriate for writing ...
Definition: base_units.cpp:480

References FormatInternalUnits(), VECTOR2< T >::x, and VECTOR2< T >::y.

◆ FormatInternalUnits() [4/4]

std::string FormatInternalUnits ( const wxSize &  aSize)

Definition at line 536 of file base_units.cpp.

537 {
538  return FormatInternalUnits( aSize.GetWidth() ) + " " + FormatInternalUnits( aSize.GetHeight() );
539 }
std::string FormatInternalUnits(int aValue)
Function FormatInternalUnits converts aValue from internal units to a string appropriate for writing ...
Definition: base_units.cpp:480

References FormatInternalUnits().

◆ From_User_Unit()

double From_User_Unit ( EDA_UNITS  aUnits,
double  aValue,
bool  aUseMils 
)

Return in internal units the value "val" given in a real unit such as "in", "mm" or "deg".

Definition at line 291 of file base_units.cpp.

292 {
293  switch( aUnits )
294  {
296  return MM_TO_IU( aValue );
297 
298  case EDA_UNITS::INCHES:
299  if( aUseMils )
300  return MILS_TO_IU( aValue );
301  else
302  return IN_TO_IU( aValue );
303 
304  case EDA_UNITS::DEGREES:
305  // Convert to "decidegrees"
306  return aValue * 10;
307 
308  default:
309  case EDA_UNITS::UNSCALED:
310  case EDA_UNITS::PERCENT:
311  return aValue;
312  }
313 }

References DEGREES, INCHES, MILLIMETRES, PERCENT, and UNSCALED.

Referenced by BASE_SCREEN::AddGrid(), DoubleValueFromString(), and PCB_BASE_FRAME::LoadSettings().

◆ GetAbbreviatedUnitsLabel()

wxString GetAbbreviatedUnitsLabel ( EDA_UNITS  aUnit,
bool  aUseMils = false 
)

Get the units string for a given units type.

Parameters
aUnits- The units requested.
Returns
The human readable units string.

Definition at line 452 of file base_units.cpp.

453 {
454  switch( aUnit )
455  {
456  case EDA_UNITS::INCHES:
457  if( aUseMils )
458  return _( "mils" );
459  else
460  return _( "in" );
461 
463  return _( "mm" );
464 
465  case EDA_UNITS::PERCENT:
466  return _( "%" );
467 
468  case EDA_UNITS::UNSCALED:
469  return wxEmptyString;
470 
471  case EDA_UNITS::DEGREES:
472  return _( "deg" );
473 
474  default:
475  return wxT( "??" );
476  }
477 }
#define _(s)
Definition: 3d_actions.cpp:31

References _, DEGREES, INCHES, MILLIMETRES, PERCENT, and UNSCALED.

Referenced by DIMENSION::AdjustDimensionDetails(), DIALOG_PLOT::applyPlotSettings(), UNIT_BINDER::ChangeValue(), DIALOG_TRACK_VIA_PROPERTIES::DIALOG_TRACK_VIA_PROPERTIES(), PANEL_PREV_3D::formatOffsetValue(), formatPreviewDimension(), PANEL_PREV_3D::formatRotationValue(), MessageTextFromValue(), DIALOG_BOARD_STATISTICS::saveReportClicked(), UNIT_BINDER::SetUnits(), UNIT_BINDER::SetValue(), TEXT_MOD_GRID_TABLE::TEXT_MOD_GRID_TABLE(), UNIT_BINDER::UNIT_BINDER(), and DIALOG_BOARD_STATISTICS::updateWidets().

◆ MessageTextFromValue() [1/3]

wxString MessageTextFromValue ( EDA_UNITS  aUnits,
int  aValue,
bool  aUseMils 
)

Definition at line 127 of file base_units.cpp.

128 {
129  return MessageTextFromValue( aUnits, double( aValue ), aUseMils );
130 }
wxString MessageTextFromValue(EDA_UNITS aUnits, int aValue, bool aUseMils)
Definition: base_units.cpp:127

References MessageTextFromValue().

Referenced by DIALOG_SELECT_NET_FROM_LIST::buildNetsList(), DIALOG_PAD_PROPERTIES::displayPrimitivesList(), formatCoord(), LIB_CIRCLE::GetMsgPanelInfo(), LIB_RECTANGLE::GetMsgPanelInfo(), LIB_TEXT::GetMsgPanelInfo(), LIB_ARC::GetMsgPanelInfo(), LIB_POLYLINE::GetMsgPanelInfo(), TEXTE_PCB::GetMsgPanelInfo(), WS_DRAW_ITEM_BASE::GetMsgPanelInfo(), LIB_BEZIER::GetMsgPanelInfo(), LIB_PIN::GetMsgPanelInfo(), SCH_BITMAP::GetMsgPanelInfo(), LIB_FIELD::GetMsgPanelInfo(), TRACK::GetMsgPanelInfo(), TEXTE_MODULE::GetMsgPanelInfo(), DRAWSEGMENT::GetMsgPanelInfo(), NETINFO_ITEM::GetMsgPanelInfo(), SCH_TEXT::GetMsgPanelInfo(), D_PAD::GetMsgPanelInfo(), TRACK::GetMsgPanelInfoBase(), VIA::GetMsgPanelInfoBase(), LIB_RECTANGLE::GetSelectMenuText(), LIB_CIRCLE::GetSelectMenuText(), PCB_TARGET::GetSelectMenuText(), LIB_POLYLINE::GetSelectMenuText(), MARKER_PCB::GetSelectMenuText(), LIB_ARC::GetSelectMenuText(), WS_DRAW_ITEM_LINE::GetSelectMenuText(), WS_DRAW_ITEM_POLYPOLYGONS::GetSelectMenuText(), SCH_LINE::GetSelectMenuText(), TRACK::GetSelectMenuText(), WS_DRAW_ITEM_RECT::GetSelectMenuText(), DRAWSEGMENT::GetSelectMenuText(), WS_DRAW_ITEM_TEXT::GetSelectMenuText(), VIA::GetSelectMenuText(), WS_DRAW_ITEM_BITMAP::GetSelectMenuText(), MessageTextFromValue(), DIALOG_BOARD_STATISTICS::saveReportClicked(), DRC_ITEM::ShowCoord(), PNS::MEANDER_SKEW_PLACER::TuningInfo(), PNS::MEANDER_PLACER::TuningInfo(), PNS::DP_MEANDER_PLACER::TuningInfo(), TRACK_WIDTH_MENU::update(), DIFF_PAIR_MENU::update(), DIALOG_BOARD_STATISTICS::updateDrillGrid(), and DIALOG_BOARD_STATISTICS::updateWidets().

◆ MessageTextFromValue() [2/3]

wxString MessageTextFromValue ( EDA_UNITS  aUnits,
long long int  aValue,
bool  aUseMils 
)

Definition at line 134 of file base_units.cpp.

135 {
136  return MessageTextFromValue( aUnits, double( aValue ), aUseMils );
137 }
wxString MessageTextFromValue(EDA_UNITS aUnits, int aValue, bool aUseMils)
Definition: base_units.cpp:127

References MessageTextFromValue().

◆ MessageTextFromValue() [3/3]

wxString MessageTextFromValue ( EDA_UNITS  aUnits,
double  aValue,
bool  aUseMils = false 
)

Function MessageTextFromValue is a helper to convert the double length aValue to a string in inches, millimeters, or unscaled units.

Should be used only to display a coordinate in status, but not in dialogs, files, etc., because the mantissa of the number displayed has 4 digits max for readability. The actual internal value could need up to 8 digits to be printed.

Use StringFromValue() instead where precision matters.

Parameters
aUnitsThe units to show the value in. The unit string is added to the message text.
aValueThe double value to convert.
aUseMilsConvert inch values to mils if true.
Returns
The converted string for display in user interface elements.

Definition at line 141 of file base_units.cpp.

142 {
143  wxString text;
144  const wxChar* format;
145  double value = To_User_Unit( aUnits, aValue, aUseMils );
146 
147  if( aUnits == EDA_UNITS::INCHES )
148  {
149  if( aUseMils )
150  {
151 #if defined( EESCHEMA )
152  format = wxT( "%.0f" );
153 #else
154  format = wxT( "%.1f" );
155 #endif
156  }
157  else
158  {
159 #if defined( EESCHEMA )
160  format = wxT( "%.3f" );
161 #else
162  format = wxT( "%.4f" );
163 #endif
164  }
165  }
166  else
167  {
168 #if defined( EESCHEMA )
169  format = wxT( "%.2f" );
170 #else
171  format = wxT( "%.3f" );
172 #endif
173  }
174 
175  text.Printf( format, value );
176  text += " ";
177 
178  text += GetAbbreviatedUnitsLabel( aUnits, aUseMils );
179 
180  return text;
181 }
double To_User_Unit(EDA_UNITS aUnit, double aValue, bool aUseMils)
Function To_User_Unit convert aValue in internal units to the appropriate user units defined by aUnit...
Definition: base_units.cpp:95
wxString GetAbbreviatedUnitsLabel(EDA_UNITS aUnit, bool aUseMils)
Get the units string for a given units type.
Definition: base_units.cpp:452

References GetAbbreviatedUnitsLabel(), INCHES, and To_User_Unit().

◆ StringFromValue()

wxString StringFromValue ( EDA_UNITS  aUnit,
double  aValue,
bool  aAddUnitSymbol = false,
bool  aUseMils = false 
)

Function StringFromValue returns the string from aValue according to units (inch, mm ...) for display, and the initial unit for value.

For readability, the mantissa has 3 or more digits (max 8 digits), the trailing 0 are removed if the mantissa has more than 3 digits and some trailing 0 This function should be used to display values in dialogs because a value entered in mm (for instance 2.0 mm) could need up to 8 digits mantissa if displayed in inch to avoid truncation or rounding made just by the printf function. otherwise the actual value is rounded when read from dialog and converted in internal units, and therefore modified.

Parameters
aUnit= display units (INCHES, MILLIMETRE ..)
aValue= value in Internal_Unit
aAddUnitSymbol= true to add symbol unit to the string value
aUseMilsIndicates mils should be used for imperial units (inches).
Returns
A wxString object containing value and optionally the symbol unit (like 2.000 mm)

Definition at line 219 of file base_units.cpp.

220 {
221  double value_to_print = To_User_Unit( aUnits, aValue, aUseMils );
222 
223 #if defined( EESCHEMA )
224  wxString stringValue = wxString::Format( wxT( "%.3f" ), value_to_print );
225 
226  // Strip trailing zeros. However, keep at least 3 digits in mantissa
227  // For readability
228  StripTrailingZeros( stringValue, 3 );
229 
230 #else
231 
232  char buf[50];
233  int len;
234 
235  if( value_to_print != 0.0 && fabs( value_to_print ) <= 0.0001 )
236  {
237  len = sprintf( buf, "%.10f", value_to_print );
238 
239  while( --len > 0 && buf[len] == '0' )
240  buf[len] = '\0';
241 
242  if( buf[len]=='.' || buf[len]==',' )
243  buf[len] = '\0';
244  else
245  ++len;
246  }
247  else
248  {
249  if( aUnits == EDA_UNITS::INCHES && aUseMils )
250  len = sprintf( buf, "%.7g", value_to_print );
251  else
252  len = sprintf( buf, "%.10g", value_to_print );
253  }
254 
255  wxString stringValue( buf, wxConvUTF8 );
256 
257 #endif
258 
259  if( aAddUnitSymbol )
260  {
261  switch( aUnits )
262  {
263  case EDA_UNITS::INCHES:
264  if( aUseMils )
265  stringValue += wxT( " mils" );
266  else
267  stringValue += wxT( " in" );
268  break;
269 
271  stringValue += wxT( " mm" );
272  break;
273 
274  case EDA_UNITS::DEGREES:
275  stringValue += wxT( " deg" );
276  break;
277 
278  case EDA_UNITS::PERCENT:
279  stringValue += wxT( "%" );
280  break;
281 
282  case EDA_UNITS::UNSCALED:
283  break;
284  }
285  }
286 
287  return stringValue;
288 }
double To_User_Unit(EDA_UNITS aUnit, double aValue, bool aUseMils)
Function To_User_Unit convert aValue in internal units to the appropriate user units defined by aUnit...
Definition: base_units.cpp:95
void StripTrailingZeros(wxString &aStringValue, unsigned aTrailingZeroAllowed)
Function StripTrailingZeros Remove trailing 0 from a string containing a converted float number.
Definition: base_units.cpp:187
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205

References DEGREES, Format(), INCHES, MILLIMETRES, PERCENT, StripTrailingZeros(), To_User_Unit(), and UNSCALED.

Referenced by PANEL_SETUP_TRACKS_AND_VIAS::AppendDiffPairs(), PANEL_SETUP_TRACKS_AND_VIAS::AppendTrackWidth(), PANEL_SETUP_TRACKS_AND_VIAS::AppendViaSize(), DIALOG_PLOT::applyPlotSettings(), BuildStackupReport(), UNIT_BINDER::ChangeValue(), ConvertOutlineToPolygon(), PCB_EDIT_FRAME::Create_MuWaveComponent(), MWAVE::CreateMicrowaveInductor(), PANEL_SETUP_BOARD_STACKUP::createRowData(), DIALOG_TRACK_VIA_PROPERTIES::DIALOG_TRACK_VIA_PROPERTIES(), LIB_PIN::getMsgPanelInfoBase(), TEXT_MOD_GRID_TABLE::GetValue(), FIELDS_GRID_TABLE< SCH_FIELD >::GetValue(), PIN_TABLE_DATA_MODEL::GetValue(), DIALOG_PLOT::init_Dialog(), DIALOG_PAD_PROPERTIES::initValues(), PANEL_SETUP_BOARD_STACKUP::onCalculateDielectricThickness(), DIALOG_TEXT_PROPERTIES::OnDimensionUnitsChange(), PANEL_SETUP_BOARD_STACKUP::onUpdateThicknessValue(), DIALOG_PAD_PROPERTIES::padValuesOK(), UNIT_BINDER::SetValue(), EDA_POSITION_CTRL::SetValue(), PANEL_SETUP_BOARD_STACKUP::synchronizeWithBoard(), PANEL_SETUP_BOARD_STACKUP::transferDataFromUIToStackup(), PANEL_EESCHEMA_SETTINGS::TransferDataToWindow(), PANEL_LIBEDIT_SETTINGS::TransferDataToWindow(), DIALOG_PAD_PRIMITIVE_POLY_PROPS::TransferDataToWindow(), UNIT_BINDER::Validate(), PANEL_SETUP_TRACKS_AND_VIAS::validateData(), and PANEL_SETUP_NETCLASSES::validateData().

◆ StripTrailingZeros()

void StripTrailingZeros ( wxString &  aStringValue,
unsigned  aTrailingZeroAllowed = 1 
)

Function StripTrailingZeros Remove trailing 0 from a string containing a converted float number.

The trailing 0 are removed if the mantissa has more than aTrailingZeroAllowed digits and some trailing 0

Definition at line 187 of file base_units.cpp.

188 {
189  struct lconv * lc = localeconv();
190  char sep = lc->decimal_point[0];
191  unsigned sep_pos = aStringValue.Find( sep );
192 
193  if( sep_pos > 0 )
194  {
195  // We want to keep at least aTrailingZeroAllowed digits after the separator
196  unsigned min_len = sep_pos + aTrailingZeroAllowed + 1;
197 
198  while( aStringValue.Len() > min_len )
199  {
200  if( aStringValue.Last() == '0' )
201  aStringValue.RemoveLast();
202  else
203  break;
204  }
205  }
206 }

Referenced by AngleToStringDegrees(), and StringFromValue().

◆ To_User_Unit()

double To_User_Unit ( EDA_UNITS  aUnit,
double  aValue,
bool  aUseMils = false 
)

Function To_User_Unit convert aValue in internal units to the appropriate user units defined by aUnit.

Returns
The converted value, in double
Parameters
aUnitThe units to convert aValue to.
aValueThe value in internal units to convert.
aUseMilsIndicates mils should be used for imperial units (inches).

Definition at line 95 of file base_units.cpp.

96 {
97  switch( aUnit )
98  {
100  return IU_TO_MM( aValue );
101 
102  case EDA_UNITS::INCHES:
103  if( aUseMils )
104  return IU_TO_MILS( aValue );
105  else
106  return IU_TO_IN( aValue );
107 
108  case EDA_UNITS::DEGREES:
109  return aValue / 10.0f;
110 
111  default:
112  return aValue;
113  }
114 }

References DEGREES, INCHES, and MILLIMETRES.

Referenced by DIMENSION::AdjustDimensionDetails(), BASE_SCREEN::BuildGridsChoiceList(), GERBVIEW_FRAME::DisplayGridMsg(), EDA_DRAW_FRAME::DisplayGridMsg(), PCB_BASE_FRAME::DisplayGridMsg(), formatPreviewDimension(), MessageTextFromValue(), PCB_BASE_FRAME::SaveSettings(), StringFromValue(), PCB_BASE_FRAME::UpdateStatusBar(), SCH_BASE_FRAME::UpdateStatusBar(), GERBVIEW_FRAME::UpdateStatusBar(), PCB_EDIT_FRAME::UpdateTrackWidthSelectBox(), and PCB_EDIT_FRAME::UpdateViaSizeSelectBox().

◆ ValueFromString()

long long int ValueFromString ( EDA_UNITS  aUnits,
const wxString &  aTextValue,
bool  aUseMils = false 
)

Function ValueFromString converts aTextValue in aUnits to internal units used by the application.

Parameters
aUnitsThe units of aTextValue.
aTextValueA reference to a wxString object containing the string to convert.
aUseMilsIndicates mils should be used for imperial units (inches).
Returns
The string from Value, according to units (inch, mm ...) for display,

Definition at line 429 of file base_units.cpp.

430 {
431  double value = DoubleValueFromString( aUnits, aTextValue, aUseMils );
432  return KiROUND<double, long long int>( value );
433 }
double DoubleValueFromString(EDA_UNITS aUnits, const wxString &aTextValue, bool aUseMils)
Function DoubleValueFromString converts aTextValue to a double.
Definition: base_units.cpp:316

References DoubleValueFromString().

Referenced by PIN_TABLE_DATA_MODEL::compare(), PCB_EDIT_FRAME::Create_MuWaveComponent(), MWAVE::CreateMicrowaveInductor(), PANEL_MODEDIT_DEFAULTS::getGridValue(), PANEL_SETUP_TEXT_AND_GRAPHICS::getGridValue(), PANEL_SETUP_NETCLASSES::getNetclassValue(), PANEL_SETUP_BOARD_STACKUP::GetPcbThickness(), DIALOG_ANNOTATE::GetStartNumber(), UNIT_BINDER::GetValue(), EDA_POSITION_CTRL::GetValue(), DIALOG_PAD_PRIMITIVE_POLY_PROPS::onCellChanging(), DIALOG_TEXT_PROPERTIES::OnDimensionUnitsChange(), PANEL_SETUP_BOARD_STACKUP::onThicknessChange(), PANEL_SETUP_BOARD_STACKUP::onUpdateThicknessValue(), TEXT_MOD_GRID_TABLE::SetValue(), FIELDS_GRID_TABLE< SCH_FIELD >::SetValue(), PIN_TABLE_DATA_MODEL::SetValue(), PANEL_SETUP_BOARD_STACKUP::transferDataFromUIToStackup(), PANEL_EESCHEMA_SETTINGS::TransferDataFromWindow(), PANEL_LIBEDIT_SETTINGS::TransferDataFromWindow(), PANEL_SETUP_TRACKS_AND_VIAS::TransferDataFromWindow(), and PANEL_SETUP_TRACKS_AND_VIAS::validateData().