KiCad PCB EDA Suite
base_units.cpp File Reference

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

#include <macros.h>
#include <base_struct.h>
#include <title_block.h>
#include <common.h>
#include <base_units.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_T 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_T aUnits, int aValue, bool aUseMils)
 
wxString MessageTextFromValue (EDA_UNITS_T 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_T aUnits, int 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_T 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_T aUnits, const wxString &aTextValue, bool aUseMils)
 Function DoubleValueFromString converts aTextValue to a double. More...
 
void FetchUnitsFromString (const wxString &aTextValue, EDA_UNITS_T &aUnits, bool &aUseMils)
 Function FetchUnitsFromString writes any unit info found in the string to aUnits and aUseMils. More...
 
int ValueFromString (EDA_UNITS_T 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_T 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 426 of file base_units.cpp.

427 {
428  wxString text;
429 
430  text.Printf( wxT( "%.3f" ), aAngle/10.0 );
431  StripTrailingZeros( text, 1 );
432 
433  return text;
434 }
void StripTrailingZeros(wxString &aStringValue, unsigned aTrailingZeroAllowed)
Function StripTrailingZeros Remove trailing 0 from a string containing a converted float number.
Definition: base_units.cpp:178

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 63 of file base_units.cpp.

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

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(), and GBR_TO_PCB_EXPORTER::writePcbPolygonItem().

◆ DoubleValueFromString()

double DoubleValueFromString ( EDA_UNITS_T  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 307 of file base_units.cpp.

308 {
309  double value;
310  double dtmp = 0;
311 
312  // Acquire the 'right' decimal point separator
313  const struct lconv* lc = localeconv();
314 
315  wxChar decimal_point = lc->decimal_point[0];
316  wxString buf( aTextValue.Strip( wxString::both ) );
317 
318  // Convert the period in decimal point
319  buf.Replace( wxT( "." ), wxString( decimal_point, 1 ) );
320 
321  // Find the end of the numeric part
322  unsigned brk_point = 0;
323 
324  while( brk_point < buf.Len() )
325  {
326  wxChar ch = buf[brk_point];
327 
328  if( !( (ch >= '0' && ch <='9') || (ch == decimal_point) || (ch == '-') || (ch == '+') ) )
329  {
330  break;
331  }
332 
333  ++brk_point;
334  }
335 
336  // Extract the numeric part
337  buf.Left( brk_point );
338 
339  buf.ToDouble( &dtmp );
340 
341  // Check the optional unit designator (2 ch significant)
342  wxString unit( buf.Mid( brk_point ).Strip( wxString::leading ).Left( 2 ).Lower() );
343 
344  if( aUnits == INCHES || aUnits == MILLIMETRES )
345  {
346  if( unit == wxT( "in" ) || unit == wxT( "\"" ) )
347  {
348  aUnits = INCHES;
349  aUseMils = false;
350  }
351  else if( unit == wxT( "mm" ) )
352  {
353  aUnits = MILLIMETRES;
354  }
355  else if( unit == wxT( "mi" ) || unit == wxT( "th" ) ) // "mils" or "thou"
356  {
357  aUnits = INCHES;
358  aUseMils = true;
359  }
360  }
361  else if( aUnits == DEGREES )
362  {
363  if( unit == wxT( "ra" ) ) // Radians
364  {
365  dtmp *= 180.0f / M_PI;
366  }
367  }
368 
369  value = From_User_Unit( aUnits, dtmp, aUseMils );
370 
371  return value;
372 }
double From_User_Unit(EDA_UNITS_T 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:282
Definition: common.h:158

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

Referenced by PROPERTIES_FRAME::CopyPrmsFromPanelToGeneral(), PROPERTIES_FRAME::CopyPrmsFromPanelToItem(), 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_T aUnits,
bool &  aUseMils 
)

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

Definition at line 375 of file base_units.cpp.

376 {
377  wxString buf( aTextValue.Strip( wxString::both ) );
378  unsigned brk_point = 0;
379 
380  while( brk_point < buf.Len() )
381  {
382  wxChar c = buf[brk_point];
383 
384  if( !( (c >= '0' && c <='9') || (c == '.') || (c == ',') || (c == '-') || (c == '+') ) )
385  break;
386 
387  ++brk_point;
388  }
389 
390  // Check the unit designator (2 ch significant)
391  wxString unit( buf.Mid( brk_point ).Strip( wxString::leading ).Left( 2 ).Lower() );
392 
393  if( unit == wxT( "in" ) || unit == wxT( "\"" ) )
394  {
395  aUnits = INCHES;
396  aUseMils = false;
397  }
398  else if( unit == wxT( "mm" ) )
399  {
400  aUnits = MILLIMETRES;
401  }
402  else if( unit == wxT( "mi" ) || unit == wxT( "th" ) ) // "mils" or "thou"
403  {
404  aUnits = INCHES;
405  aUseMils = true;
406  }
407  else if( unit == wxT( "de" ) || unit == wxT( "ra" ) ) // "deg" or "rad"
408  {
409  aUnits = DEGREES;
410  }
411 }
Definition: common.h:158

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 498 of file base_units.cpp.

499 {
500  char temp[50];
501  int len;
502 
503  len = snprintf( temp, sizeof(temp), "%.10g", aAngle / 10.0 );
504 
505  return std::string( temp, len );
506 }

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 465 of file base_units.cpp.

466 {
467  char buf[50];
468  double engUnits = aValue;
469  int len;
470 
471 #ifndef EESCHEMA
472  engUnits /= IU_PER_MM;
473 #endif
474 
475  if( engUnits != 0.0 && fabs( engUnits ) <= 0.0001 )
476  {
477  len = snprintf( buf, sizeof(buf), "%.10f", engUnits );
478 
479  while( --len > 0 && buf[len] == '0' )
480  buf[len] = '\0';
481 
482 #ifndef EESCHEMA
483  if( buf[len] == '.' )
484  buf[len] = '\0';
485  else
486 #endif
487  ++len;
488  }
489  else
490  {
491  len = snprintf( buf, sizeof(buf), "%.10g", engUnits );
492  }
493 
494  return std::string( buf, len );
495 }

Referenced by 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 509 of file base_units.cpp.

510 {
511  return FormatInternalUnits( aPoint.x ) + " " + FormatInternalUnits( aPoint.y );
512 }
std::string FormatInternalUnits(int aValue)
Function FormatInternalUnits converts aValue from internal units to a string appropriate for writing ...
Definition: base_units.cpp:465

References FormatInternalUnits().

◆ FormatInternalUnits() [3/4]

std::string FormatInternalUnits ( const VECTOR2I aPoint)

Definition at line 515 of file base_units.cpp.

516 {
517  return FormatInternalUnits( aPoint.x ) + " " + FormatInternalUnits( aPoint.y );
518 }
std::string FormatInternalUnits(int aValue)
Function FormatInternalUnits converts aValue from internal units to a string appropriate for writing ...
Definition: base_units.cpp:465

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

◆ FormatInternalUnits() [4/4]

std::string FormatInternalUnits ( const wxSize &  aSize)

Definition at line 521 of file base_units.cpp.

522 {
523  return FormatInternalUnits( aSize.GetWidth() ) + " " + FormatInternalUnits( aSize.GetHeight() );
524 }
std::string FormatInternalUnits(int aValue)
Function FormatInternalUnits converts aValue from internal units to a string appropriate for writing ...
Definition: base_units.cpp:465

References FormatInternalUnits().

◆ From_User_Unit()

double From_User_Unit ( EDA_UNITS_T  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 282 of file base_units.cpp.

283 {
284  switch( aUnits )
285  {
286  case MILLIMETRES:
287  return MM_TO_IU( aValue );
288 
289  case INCHES:
290  if( aUseMils )
291  return MILS_TO_IU( aValue );
292  else
293  return IN_TO_IU( aValue );
294 
295  case DEGREES:
296  // Convert to "decidegrees"
297  return aValue * 10;
298 
299  default:
300  case UNSCALED_UNITS:
301  case PERCENT:
302  return aValue;
303  }
304 }
Definition: common.h:158

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

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

◆ GetAbbreviatedUnitsLabel()

wxString GetAbbreviatedUnitsLabel ( EDA_UNITS_T  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 437 of file base_units.cpp.

438 {
439  switch( aUnit )
440  {
441  case INCHES:
442  if( aUseMils )
443  return _( "mils" );
444  else
445  return _( "in" );
446 
447  case MILLIMETRES:
448  return _( "mm" );
449 
450  case PERCENT:
451  return _( "%" );
452 
453  case UNSCALED_UNITS:
454  return wxEmptyString;
455 
456  case DEGREES:
457  return _( "deg" );
458 
459  default:
460  return wxT( "??" );
461  }
462 }
Definition: common.h:158
#define _(s)

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

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

◆ MessageTextFromValue() [1/2]

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

Definition at line 125 of file base_units.cpp.

126 {
127  return MessageTextFromValue( aUnits, (double) aValue, aUseMils );
128 }
wxString MessageTextFromValue(EDA_UNITS_T aUnits, int aValue, bool aUseMils)
Definition: base_units.cpp:125

References MessageTextFromValue().

Referenced by DIMENSION::AdjustDimensionDetails(), DIALOG_SELECT_NET_FROM_LIST::buildNetsList(), DIALOG_PAD_PROPERTIES::displayPrimitivesList(), formatCoord(), LIB_CIRCLE::GetMsgPanelInfo(), LIB_RECTANGLE::GetMsgPanelInfo(), LIB_ARC::GetMsgPanelInfo(), TEXTE_PCB::GetMsgPanelInfo(), LIB_POLYLINE::GetMsgPanelInfo(), LIB_TEXT::GetMsgPanelInfo(), WS_DRAW_ITEM_BASE::GetMsgPanelInfo(), LIB_BEZIER::GetMsgPanelInfo(), LIB_PIN::GetMsgPanelInfo(), SCH_BITMAP::GetMsgPanelInfo(), LIB_FIELD::GetMsgPanelInfo(), TRACK::GetMsgPanelInfo(), TEXTE_MODULE::GetMsgPanelInfo(), SCH_TEXT::GetMsgPanelInfo(), DRAWSEGMENT::GetMsgPanelInfo(), NETINFO_ITEM::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(), DRC_ITEM::ShowCoord(), PNS::MEANDER_SKEW_PLACER::TuningInfo(), PNS::MEANDER_PLACER::TuningInfo(), PNS::DP_MEANDER_PLACER::TuningInfo(), TRACK_WIDTH_MENU::update(), and DIFF_PAIR_MENU::update().

◆ MessageTextFromValue() [2/2]

wxString MessageTextFromValue ( EDA_UNITS_T  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 132 of file base_units.cpp.

133 {
134  wxString text;
135  const wxChar* format;
136  double value = To_User_Unit( aUnits, aValue, aUseMils );
137 
138  if( aUnits == INCHES )
139  {
140  if( aUseMils )
141  {
142 #if defined( EESCHEMA )
143  format = wxT( "%.0f" );
144 #else
145  format = wxT( "%.1f" );
146 #endif
147  }
148  else
149  {
150 #if defined( EESCHEMA )
151  format = wxT( "%.3f" );
152 #else
153  format = wxT( "%.4f" );
154 #endif
155  }
156  }
157  else
158  {
159 #if defined( EESCHEMA )
160  format = wxT( "%.2f" );
161 #else
162  format = wxT( "%.3f" );
163 #endif
164  }
165 
166  text.Printf( format, value );
167  text += " ";
168 
169  text += GetAbbreviatedUnitsLabel( aUnits, aUseMils );
170 
171  return text;
172 }
double To_User_Unit(EDA_UNITS_T 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:93
Definition: common.h:158
wxString GetAbbreviatedUnitsLabel(EDA_UNITS_T aUnit, bool aUseMils)
Get the units string for a given units type.
Definition: base_units.cpp:437

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

◆ StringFromValue()

wxString StringFromValue ( EDA_UNITS_T  aUnit,
int  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 210 of file base_units.cpp.

211 {
212  double value_to_print = To_User_Unit( aUnits, aValue, aUseMils );
213 
214 #if defined( EESCHEMA )
215  wxString stringValue = wxString::Format( wxT( "%.3f" ), value_to_print );
216 
217  // Strip trailing zeros. However, keep at least 3 digits in mantissa
218  // For readability
219  StripTrailingZeros( stringValue, 3 );
220 
221 #else
222 
223  char buf[50];
224  int len;
225 
226  if( value_to_print != 0.0 && fabs( value_to_print ) <= 0.0001 )
227  {
228  len = sprintf( buf, "%.10f", value_to_print );
229 
230  while( --len > 0 && buf[len] == '0' )
231  buf[len] = '\0';
232 
233  if( buf[len]=='.' || buf[len]==',' )
234  buf[len] = '\0';
235  else
236  ++len;
237  }
238  else
239  {
240  if( aUnits == INCHES && aUseMils )
241  len = sprintf( buf, "%.7g", value_to_print );
242  else
243  len = sprintf( buf, "%.10g", value_to_print );
244  }
245 
246  wxString stringValue( buf, wxConvUTF8 );
247 
248 #endif
249 
250  if( aAddUnitSymbol )
251  {
252  switch( aUnits )
253  {
254  case INCHES:
255  if( aUseMils )
256  stringValue += wxT( " mils" );
257  else
258  stringValue += wxT( " in" );
259  break;
260 
261  case MILLIMETRES:
262  stringValue += wxT( " mm" );
263  break;
264 
265  case DEGREES:
266  stringValue += wxT( " deg" );
267  break;
268 
269  case PERCENT:
270  stringValue += wxT( "%" );
271  break;
272 
273  case UNSCALED_UNITS:
274  break;
275  }
276  }
277 
278  return stringValue;
279 }
void StripTrailingZeros(wxString &aStringValue, unsigned aTrailingZeroAllowed)
Function StripTrailingZeros Remove trailing 0 from a string containing a converted float number.
Definition: base_units.cpp:178
double To_User_Unit(EDA_UNITS_T 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:93
Definition: common.h:158
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_UNITS.

Referenced by PANEL_SETUP_TRACKS_AND_VIAS::AppendDiffPairs(), PANEL_SETUP_TRACKS_AND_VIAS::AppendTrackWidth(), PANEL_SETUP_TRACKS_AND_VIAS::AppendViaSize(), DIALOG_PLOT::applyPlotSettings(), UNIT_BINDER::ChangeValue(), ConvertOutlineToPolygon(), PCB_EDIT_FRAME::Create_MuWaveComponent(), MWAVE::CreateMicrowaveInductor(), 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(), DIALOG_TEXT_PROPERTIES::OnDimensionUnitsChange(), DIALOG_PAD_PROPERTIES::padValuesOK(), UNIT_BINDER::SetValue(), EDA_POSITION_CTRL::SetValue(), 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 178 of file base_units.cpp.

179 {
180  struct lconv * lc = localeconv();
181  char sep = lc->decimal_point[0];
182  unsigned sep_pos = aStringValue.Find( sep );
183 
184  if( sep_pos > 0 )
185  {
186  // We want to keep at least aTrailingZeroAllowed digits after the separator
187  unsigned min_len = sep_pos + aTrailingZeroAllowed + 1;
188 
189  while( aStringValue.Len() > min_len )
190  {
191  if( aStringValue.Last() == '0' )
192  aStringValue.RemoveLast();
193  else
194  break;
195  }
196  }
197 }

Referenced by AngleToStringDegrees(), and StringFromValue().

◆ To_User_Unit()

double To_User_Unit ( EDA_UNITS_T  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 93 of file base_units.cpp.

94 {
95  switch( aUnit )
96  {
97  case MILLIMETRES:
98  return IU_TO_MM( aValue );
99 
100  case INCHES:
101  if( aUseMils )
102  return IU_TO_MILS( aValue );
103  else
104  return IU_TO_IN( aValue );
105 
106  case DEGREES:
107  return aValue / 10.0f;
108 
109  default:
110  return aValue;
111  }
112 }
Definition: common.h:158

References DEGREES, INCHES, and MILLIMETRES.

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

◆ ValueFromString()

int ValueFromString ( EDA_UNITS_T  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 414 of file base_units.cpp.

415 {
416  double value = DoubleValueFromString( aUnits, aTextValue, aUseMils );
417  return KiROUND( value );
418 }
static int KiROUND(double v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:118
double DoubleValueFromString(EDA_UNITS_T aUnits, const wxString &aTextValue, bool aUseMils)
Function DoubleValueFromString converts aTextValue to a double.
Definition: base_units.cpp:307

References DoubleValueFromString(), and KiROUND().

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(), DIALOG_ANNOTATE::GetStartNumber(), UNIT_BINDER::GetValue(), EDA_POSITION_CTRL::GetValue(), DIALOG_PAD_PRIMITIVE_POLY_PROPS::onCellChanging(), DIALOG_TEXT_PROPERTIES::OnDimensionUnitsChange(), TEXT_MOD_GRID_TABLE::SetValue(), FIELDS_GRID_TABLE< SCH_FIELD >::SetValue(), PIN_TABLE_DATA_MODEL::SetValue(), PANEL_EESCHEMA_SETTINGS::TransferDataFromWindow(), PANEL_LIBEDIT_SETTINGS::TransferDataFromWindow(), PANEL_SETUP_TRACKS_AND_VIAS::TransferDataFromWindow(), and PANEL_SETUP_TRACKS_AND_VIAS::validateData().