haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add the ORIGIN_TRANSFORMS class 

This commit adds the ORIGIN_TRANSFORMS class to support Display Origin
Transforms in all KiCad applications.

Functions are provided to perform four basic types of origin coordinate
transforms:
  * Transform a relative coordinate from internal to display form
  * Transform a relative coordinate from display to internal form
  * Transform an absolute coordinate from internal to display form
  * Transform an absolute coordinate from display to internal form

These functions are supported for data types "int", "long long int",
and "double". The default implementations for all but "int" simply
return their input unchanged; the implementation for "int" invokes
the implementation for "long long int".

The expectation is that the different KiCad applications will create
derived classes from this base class and override the functions as
needed. Protected template functions are provided for the standard
translations to maintain consistency within the derived classes.
This commit is contained in:
Reece R. Pollack 2020-07-04 22:02:12 -04:00 committed by Seth Hillbrand
parent 731f247eb3
commit 3fec2805ec
3 changed files with 265 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
common/CMakeLists.txt
View File

@ -343,6 +343,7 @@ set( COMMON_SRCS
msgpanel.cpp
netclass.cpp
observable.cpp
origin_transforms.cpp
prependpath.cpp
printout.cpp
project.cpp

69
common/origin_transforms.cpp Normal file
View File

@ -0,0 +1,69 @@
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2019-2020 Reece R. Pollack <reece@his.com>
* Copyright (C) 1992-2019 KiCad Developers, see AUTHORS.txt for contributors.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <origin_transforms.h>
ORIGIN_TRANSFORMS::ORIGIN_TRANSFORMS()
{}
ORIGIN_TRANSFORMS::~ORIGIN_TRANSFORMS()
{}
int ORIGIN_TRANSFORMS::ToDisplay( int aValue,
COORD_TYPES_T aCoordType )
{
return ToDisplay( static_cast<long long int>(aValue), aCoordType );
}
long long int ORIGIN_TRANSFORMS::ToDisplay( long long int aValue,
COORD_TYPES_T aCoordType )
{
return aValue;
}
double ORIGIN_TRANSFORMS::ToDisplay( double aValue,
COORD_TYPES_T aCoordType )
{
return aValue;
}
int ORIGIN_TRANSFORMS::FromDisplay( int aValue,
COORD_TYPES_T aCoordType )
{
return FromDisplay( static_cast<long long int>(aValue), aCoordType );
}
long long int ORIGIN_TRANSFORMS::FromDisplay( long long int aValue,
COORD_TYPES_T aCoordType )
{
return aValue;
}
double ORIGIN_TRANSFORMS::FromDisplay( double aValue,
COORD_TYPES_T aCoordType )
{
return aValue;
}

195
include/origin_transforms.h Normal file
View File

@ -0,0 +1,195 @@
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2019-2020 Reece R. Pollack <reece@his.com>
* Copyright (C) 1992-2019 KiCad Developers, see AUTHORS.txt for contributors.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef ORIGIN_TRANSFORMS_H_
#define ORIGIN_TRANSFORMS_H_ 1
/**
* A class to perform either relative or absolute display origin
* transforms for a single axis of a point.
*
* The coordinate argument is transformed between an offset from
* the internal origin and an offset from the user-specified origin
* and coordinate direction.
*
* The functions are templated to allow use with any size scalar
* parameter: an int, a long long int, or a double.
*/
class ORIGIN_TRANSFORMS {
public:
/**
* The supported Display Origin Transform types
*
* Absolute coordinates require both translation and direction
* inversion. Relative coordinates require only direction inversion.
*/
enum COORD_TYPES_T {
NOT_A_COORD, //< A non-coordinate value, never transformed
ABS_X_COORD, //< An absolute X coordinate
ABS_Y_COORD, //< An absolute Y coordinate
REL_X_COORD, //< A relative X coordinate
REL_Y_COORD, //< A relative Y coordinate
};
public:
ORIGIN_TRANSFORMS();
virtual ~ORIGIN_TRANSFORMS();
// =============== Single-axis Transforms ===============
virtual int ToDisplay( int aValue,
COORD_TYPES_T aCoordType );
virtual long long int ToDisplay( long long int aValue,
COORD_TYPES_T aCoordType );
virtual double ToDisplay( double aValue,
COORD_TYPES_T aCoordType );
virtual int FromDisplay( int aValue,
COORD_TYPES_T aCoordType );
virtual long long int FromDisplay( long long int aValue,
COORD_TYPES_T aCoordType );
virtual double FromDisplay( double aValue,
COORD_TYPES_T aCoordType );
// =============== Two-axis Transforms ===============
template<class T>
T ToDisplayAbs( const T& aValue )
{
T displayValue;
displayValue.x = ToDisplay( aValue.x, ABS_X_COORD );
displayValue.x = ToDisplay( aValue.y, ABS_Y_COORD );
return displayValue;
}
template<class T>
T ToDisplayRel( const T& aValue )
{
T displayValue;
displayValue.x = ToDisplay( aValue.x, REL_X_COORD );
displayValue.x = ToDisplay( aValue.y, REL_Y_COORD );
return displayValue;
}
template<class T>
T FromDisplayAbs( const T& aValue )
{
T displayValue;
displayValue.x = FromDisplay( aValue.x, ABS_X_COORD );
displayValue.x = FromDisplay( aValue.y, ABS_Y_COORD );
return displayValue;
}
template<class T>
T FromDisplayRel( const T& aValue )
{
T displayValue;
displayValue.x = FromDisplay( aValue.x, REL_X_COORD );
displayValue.x = FromDisplay( aValue.y, REL_Y_COORD );
return displayValue;
}
protected:
// =============== Generic Relative Transforms ===============
template<class T> inline static
T ToDisplayRel( T aInternalValue,
bool aInvertAxis )
{
T displayValue = aInternalValue;
// Invert the direction if needed
if( aInvertAxis && (displayValue != static_cast<T>(0)) )
displayValue = -displayValue;
return displayValue;
}
template<class T> inline static
T FromDisplayRel( T aDisplayValue,
bool aInvertAxis )
{
T internalValue = aDisplayValue;
// Invert the direction if needed
if( aInvertAxis && (internalValue != static_cast<T>(0)) )
internalValue = -internalValue;
return internalValue;
}
// =============== Generic Absolute Transforms ===============
template<class T> inline static
T ToDisplayAbs( T aInternalValue,
int aUserOrigin,
bool aInvertAxis )
{
T displayValue = aInternalValue;
// Make the value relative to the internal origin
displayValue -= aUserOrigin;
// Invert the direction if needed
if( aInvertAxis && (displayValue != static_cast<T>(0)) )
displayValue = -displayValue;
return displayValue;
}
template<class T> inline static
T FromDisplayAbs( T aDisplayValue,
int aUserOrigin,
bool aInvertAxis )
{
T internalValue = aDisplayValue;
// Invert the direction if needed
if( aInvertAxis && (internalValue != static_cast<T>(0)) )
internalValue = -internalValue;
// Make the value relative to the internal origin
internalValue += aUserOrigin;
return internalValue;
}
};
#endif // ORIGIN_TRANSFORMS_H