diff options
Diffstat (limited to 'eeschema/lib_pin.cpp')
| -rw-r--r-- | eeschema/lib_pin.cpp | 2314 |
1 files changed, 2314 insertions, 0 deletions
diff --git a/eeschema/lib_pin.cpp b/eeschema/lib_pin.cpp new file mode 100644 index 0000000..e4b221f --- /dev/null +++ b/eeschema/lib_pin.cpp @@ -0,0 +1,2314 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2015 Jean-Pierre Charras, jp.charras at wanadoo.fr + * Copyright (C) 2015 Wayne Stambaugh <stambaughw@verizon.net> + * Copyright (C) 1992-2015 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 + */ + +/** + * @file lib_pin.cpp + */ + +#include <fctsys.h> +#include <pgm_base.h> +#include <gr_basic.h> +#include <macros.h> +#include <trigo.h> +#include <class_drawpanel.h> +#include <drawtxt.h> +#include <plot_common.h> +#include <schframe.h> +#include <richio.h> +#include <base_units.h> +#include <msgpanel.h> + +#include <general.h> +#include <libeditframe.h> +#include <class_libentry.h> +#include <lib_pin.h> +#include <transform.h> +#include <sch_component.h> + + +static const int pin_orientation_codes[] = +{ + PIN_RIGHT, + PIN_LEFT, + PIN_UP, + PIN_DOWN +}; + + +#define PIN_ORIENTATION_CNT DIM( pin_orientation_codes ) + +// bitmaps to show pins orientations in dialog editor +// must have same order than pin_orientation_names +static const BITMAP_DEF iconsPinsOrientations[] = +{ + pinorient_right_xpm, + pinorient_left_xpm, + pinorient_up_xpm, + pinorient_down_xpm, +}; + + +// bitmaps to show pins shapes in dialog editor +// must have same order than pin_style_names +static BITMAP_DEF iconsPinsShapes[] = +{ + pinshape_normal_xpm, + pinshape_invert_xpm, + pinshape_clock_normal_xpm, + pinshape_clock_invert_xpm, + pinshape_active_low_input_xpm, + pinshape_clock_active_low_xpm, + pinshape_active_low_output_xpm, + pinshape_clock_fall_xpm, + pinshape_nonlogic_xpm +}; + + + +static const int pin_style_codes[] = +{ + NONE, + INVERT, + CLOCK, + CLOCK | INVERT, + LOWLEVEL_IN, + LOWLEVEL_IN | CLOCK, + LOWLEVEL_OUT, + CLOCK_FALL, + NONLOGIC +}; + +#define PIN_STYLE_CNT DIM( pin_style_codes ) + +// bitmaps to show pins electrical type in dialog editor +// must have same order than enum ElectricPinType (see lib_pin.h) +static const BITMAP_DEF iconsPinsElectricalType[] = +{ + pintype_input_xpm, + pintype_output_xpm, + pintype_bidi_xpm, + pintype_3states_xpm, + pintype_passive_xpm, + pintype_notspecif_xpm, + pintype_powerinput_xpm, + pintype_poweroutput_xpm, + pintype_opencoll_xpm, + pintype_openemit_xpm, + pintype_noconnect_xpm +}; + +#define PIN_ELECTRICAL_TYPE_CNT DIM( iconsPinsElectricalType ) + + +const wxString LIB_PIN::GetCanonicalElectricalTypeName( unsigned aType ) +{ + // These strings are the canonical name of the electrictal type + // Not translated, no space in name, only ASCII chars. + // to use when the string name must be known and well defined + // must have same order than enum ElectricPinType (see lib_pin.h) + static const wxChar* msgPinElectricType[] = + { + wxT( "input" ), + wxT( "output" ), + wxT( "BiDi" ), + wxT( "3state" ), + wxT( "passive" ), + wxT( "unspc" ), + wxT( "power_in" ), + wxT( "power_out" ), + wxT( "openCol" ), + wxT( "openEm" ), + wxT( "NotConnected" ), + wxT( "???" ) + }; + + if( aType > PIN_NMAX ) + aType = PIN_NMAX; + + return msgPinElectricType[ aType ]; +} + + +// Helper functions to get the pin orientation name from pin_orientation_codes +// Note: the strings are *not* static because they are translated and must be built +// on the fly, to be properly translated + +static const wxString getPinOrientationName( unsigned aPinOrientationCode ) +{ + /* Note: The following name lists are sentence capitalized per the GNOME UI + * standards for list controls. Please do not change the capitalization + * of these strings unless the GNOME UI standards are changed. + */ + const wxString pin_orientation_names[] = + { + _( "Right" ), + _( "Left" ), + _( "Up" ), + _( "Down" ), + wxT( "???" ) + }; + + if( aPinOrientationCode > PIN_ORIENTATION_CNT ) + aPinOrientationCode = PIN_ORIENTATION_CNT; + + return pin_orientation_names[ aPinOrientationCode ]; +} + +const wxString LIB_PIN::GetElectricalTypeName( unsigned aPinsElectricalType ) +{ + const wxString pin_electrical_type_names[] = + { // Keep these translated strings not static + _( "Input" ), + _( "Output" ), + _( "Bidirectional" ), + _( "Tri-state" ), + _( "Passive" ), + _( "Unspecified" ), + _( "Power input" ), + _( "Power output" ), + _( "Open collector" ), + _( "Open emitter" ), + _( "Not connected" ), + wxT( "???" ) + }; + + if( aPinsElectricalType > PIN_ELECTRICAL_TYPE_CNT ) + aPinsElectricalType = PIN_ELECTRICAL_TYPE_CNT; + + return pin_electrical_type_names[ aPinsElectricalType ]; +} + +static const wxString getPinStyleName( unsigned aPinsStyle ) +{ + const wxString pin_style_names[] = + { // Keep these translated strings not static + _( "Line" ), + _( "Inverted" ), + _( "Clock" ), + _( "Inverted clock" ), + _( "Input low" ), + _( "Clock low" ), + _( "Output low" ), + _( "Falling edge clock" ), + _( "NonLogic" ), + wxT( "???" ) + }; + + if( aPinsStyle > PIN_STYLE_CNT ) + aPinsStyle = PIN_STYLE_CNT; + + return pin_style_names[ aPinsStyle ]; +} + + +/// Utility for getting the size of the 'internal' pin decorators (as a radius) +// i.e. the clock symbols (falling clock is actually external but is of +// the same kind) + +static int InternalPinDecoSize( const LIB_PIN &aPin ) +{ + return aPin.GetNameTextSize() / 2; +} + +/// Utility for getting the size of the 'external' pin decorators (as a radius) +// i.e. the negation circle, the polarity 'slopes' and the nonlogic +// marker +static int ExternalPinDecoSize( const LIB_PIN &aPin ) +{ + return aPin.GetNumberTextSize() / 2; +} + +LIB_PIN::LIB_PIN( LIB_PART* aParent ) : + LIB_ITEM( LIB_PIN_T, aParent ) +{ + m_length = LIB_EDIT_FRAME::GetDefaultPinLength(); + m_orientation = PIN_RIGHT; // Pin orient: Up, Down, Left, Right + m_shape = NONE; // Pin shape, bitwise. + m_type = PIN_UNSPECIFIED; // electrical type of pin + m_attributes = 0; // bit 0 != 0: pin invisible + m_number = 0; // pin number (i.e. 4 ASCII chars) + m_numTextSize = LIB_EDIT_FRAME::GetPinNumDefaultSize(); + m_nameTextSize = LIB_EDIT_FRAME::GetPinNameDefaultSize(); + m_width = 0; + m_typeName = _( "Pin" ); +} + + +void LIB_PIN::SetName( const wxString& aName ) +{ + wxString tmp = ( aName.IsEmpty() ) ? wxT( "~" ) : aName; + + tmp.Replace( wxT( " " ), wxT( "_" ) ); + + if( m_name != tmp ) + { + m_name = tmp; + SetModified(); + } + + if( GetParent() == NULL ) + return; + + LIB_PINS pinList; + GetParent()->GetPins( pinList ); + + for( size_t i = 0; i < pinList.size(); i++ ) + { + if( ( pinList[i]->m_Flags & IS_LINKED ) == 0 || pinList[i]->m_name == m_name ) + continue; + + pinList[i]->m_name = m_name; + SetModified(); + } +} + + +void LIB_PIN::SetNameTextSize( int size ) +{ + if( size != m_nameTextSize ) + { + m_nameTextSize = size; + SetModified(); + } + + if( GetParent() == NULL ) + return; + + LIB_PINS pinList; + GetParent()->GetPins( pinList ); + + for( size_t i = 0; i < pinList.size(); i++ ) + { + if( ( pinList[i]->m_Flags & IS_LINKED ) == 0 || pinList[i]->m_nameTextSize == size ) + continue; + + pinList[i]->m_nameTextSize = size; + SetModified(); + } +} + + +void LIB_PIN::SetNumber( const wxString& number ) +{ + wxString tmp = ( number.IsEmpty() ) ? wxT( "~" ) : number; + + tmp.Replace( wxT( " " ), wxT( "_" ) ); + long oldNumber = m_number; + SetPinNumFromString( tmp ); + + if( m_number != oldNumber ) + SetFlags( IS_CHANGED ); + + /* Others pin numbers marked by EnableEditMode() are not modified + * because each pin has its own number + */ +} + + +void LIB_PIN::SetNumberTextSize( int size ) +{ + if( size != m_numTextSize ) + { + m_numTextSize = size; + SetModified(); + } + + if( GetParent() == NULL ) + return; + + LIB_PINS pinList; + GetParent()->GetPins( pinList ); + + for( size_t i = 0; i < pinList.size(); i++ ) + { + if( ( pinList[i]->m_Flags & IS_LINKED ) == 0 || pinList[i]->m_numTextSize == size ) + continue; + + pinList[i]->m_numTextSize = size; + SetModified(); + } +} + + +void LIB_PIN::SetOrientation( int orientation ) +{ + if( m_orientation != orientation ) + { + m_orientation = orientation; + SetModified(); + } + + if( GetParent() == NULL ) + return; + + LIB_PINS pinList; + GetParent()->GetPins( pinList ); + + for( size_t i = 0; i < pinList.size(); i++ ) + { + if( ( pinList[i]->m_Flags & IS_LINKED ) == 0 || + pinList[i]->m_orientation == orientation ) + continue; + + pinList[i]->m_orientation = orientation; + SetModified(); + } +} + + +void LIB_PIN::SetShape( int aShape ) +{ + if( m_shape != aShape ) + { + m_shape = aShape; + SetModified(); + } + + if( GetParent() == NULL ) + return; + + LIB_PINS pinList; + GetParent()->GetPins( pinList ); + + for( size_t i = 0; i < pinList.size(); i++ ) + { + if( ( pinList[i]->m_Flags & IS_LINKED ) == 0 + || pinList[i]->m_Convert != m_Convert + || pinList[i]->m_shape == aShape ) + continue; + + pinList[i]->m_shape = aShape; + SetModified(); + } +} + + +void LIB_PIN::SetType( int aType ) +{ + if( aType < 0 ) + aType = 0; + + if( aType >= (int)PIN_ELECTRICAL_TYPE_CNT ) + aType = PIN_ELECTRICAL_TYPE_CNT - 1; + + if( m_type != aType ) + { + m_type = aType; + SetModified(); + } + + if( GetParent() == NULL ) + return; + + LIB_PINS pinList; + GetParent()->GetPins( pinList ); + + for( size_t i = 0; i < pinList.size(); i++ ) + { + if( ( pinList[i]->m_Flags & IS_LINKED ) == 0 || pinList[i]->m_type == aType ) + continue; + + pinList[i]->m_type = aType; + SetModified(); + } +} + + +void LIB_PIN::SetLength( int length ) +{ + if( m_length != length ) + { + m_length = length; + SetModified(); + } + + if( GetParent() == NULL ) + return; + + LIB_PINS pinList; + GetParent()->GetPins( pinList ); + + for( size_t i = 0; i < pinList.size(); i++ ) + { + if( ( pinList[i]->m_Flags & IS_LINKED ) == 0 + || pinList[i]->m_Convert != m_Convert + || pinList[i]->m_length == length ) + continue; + + pinList[i]->m_length = length; + SetModified(); + } +} + + +void LIB_PIN::SetPartNumber( int part ) +{ + if( m_Unit == part ) + return; + + m_Unit = part; + SetModified(); + + if( m_Unit == 0 ) + { + LIB_PIN* pin; + LIB_PIN* tmp = GetParent()->GetNextPin(); + + while( tmp != NULL ) + { + pin = tmp; + tmp = GetParent()->GetNextPin( pin ); + + if( pin->m_Flags == 0 || pin == this + || ( m_Convert && ( m_Convert != pin->m_Convert ) ) + || ( m_position != pin->m_position ) + || ( pin->m_orientation != m_orientation ) ) + continue; + + GetParent()->RemoveDrawItem( (LIB_ITEM*) pin ); + } + } +} + + +void LIB_PIN::SetConversion( int style ) +{ + if( m_Convert == style ) + return; + + m_Convert = style; + SetFlags( IS_CHANGED ); + + if( style == 0 ) + { + LIB_PIN* pin; + LIB_PIN* tmp = GetParent()->GetNextPin(); + + while( tmp != NULL ) + { + pin = tmp; + tmp = GetParent()->GetNextPin( pin ); + + if( ( pin->m_Flags & IS_LINKED ) == 0 + || ( pin == this ) + || ( m_Unit && ( m_Unit != pin->m_Unit ) ) + || ( m_position != pin->m_position ) + || ( pin->m_orientation != m_orientation ) ) + continue; + + GetParent()->RemoveDrawItem( (LIB_ITEM*) pin ); + } + } +} + + +void LIB_PIN::SetVisible( bool visible ) +{ + if( visible == IsVisible() ) + return; + + if( visible ) + m_attributes &= ~PIN_INVISIBLE; + else + m_attributes |= PIN_INVISIBLE; + + SetModified(); + + if( GetParent() == NULL ) + return; + + LIB_PINS pinList; + GetParent()->GetPins( pinList ); + + for( size_t i = 0; i < pinList.size(); i++ ) + { + if( ( pinList[i]->m_Flags & IS_LINKED ) == 0 || pinList[i]->IsVisible() == visible ) + continue; + + if( visible ) + pinList[i]->m_attributes &= ~PIN_INVISIBLE; + else + pinList[i]->m_attributes |= PIN_INVISIBLE; + + SetModified(); + } +} + + +void LIB_PIN::EnableEditMode( bool enable, bool editPinByPin ) +{ + LIB_PINS pinList; + + if( GetParent() == NULL ) + return; + + GetParent()->GetPins( pinList ); + + for( size_t i = 0; i < pinList.size(); i++ ) + { + if( pinList[i] == this ) + continue; + + if( ( pinList[i]->m_position == m_position ) + && ( pinList[i]->m_orientation == m_orientation ) + && !IsNew() + && editPinByPin == false + && enable ) + pinList[i]->SetFlags( IS_LINKED | IN_EDIT ); + else + pinList[i]->ClearFlags( IS_LINKED | IN_EDIT ); + } +} + + +bool LIB_PIN::HitTest( const wxPoint& aPosition ) const +{ + return HitTest( aPosition, 0, DefaultTransform ); +} + + +bool LIB_PIN::HitTest( const wxPoint &aPosition, int aThreshold, const TRANSFORM& aTransform ) const +{ + if( aThreshold < 0 ) + aThreshold = 0; + + TRANSFORM transform = DefaultTransform; + DefaultTransform = aTransform; + + EDA_RECT rect = GetBoundingBox(); + rect.Inflate( aThreshold ); + + //Restore matrix + DefaultTransform = transform; + + return rect.Contains( aPosition ); +} + + +bool LIB_PIN::Save( OUTPUTFORMATTER& aFormatter ) +{ + wxString StringPinNum; + int Etype; + + switch( m_type ) + { + default: + case PIN_INPUT: + Etype = 'I'; + break; + + case PIN_OUTPUT: + Etype = 'O'; + break; + + case PIN_BIDI: + Etype = 'B'; + break; + + case PIN_TRISTATE: + Etype = 'T'; + break; + + case PIN_PASSIVE: + Etype = 'P'; + break; + + case PIN_UNSPECIFIED: + Etype = 'U'; + break; + + case PIN_POWER_IN: + Etype = 'W'; + break; + + case PIN_POWER_OUT: + Etype = 'w'; + break; + + case PIN_OPENCOLLECTOR: + Etype = 'C'; + break; + + case PIN_OPENEMITTER: + Etype = 'E'; + break; + + case PIN_NC: + Etype = 'N'; + break; + } + + PinStringNum( StringPinNum ); + + if( StringPinNum.IsEmpty() ) + StringPinNum = wxT( "~" ); + + if( !m_name.IsEmpty() ) + { + if( aFormatter.Print( 0, "X %s", TO_UTF8( m_name ) ) < 0 ) + return false; + } + else + { + if( aFormatter.Print( 0, "X ~" ) < 0 ) + return false; + } + + if( aFormatter.Print( 0, " %s %d %d %d %c %d %d %d %d %c", + TO_UTF8( StringPinNum ), m_position.x, m_position.y, + (int) m_length, (int) m_orientation, m_numTextSize, m_nameTextSize, + m_Unit, m_Convert, Etype ) < 0 ) + return false; + + if( m_shape || !IsVisible() ) + { + if( aFormatter.Print( 0, " " ) < 0 ) + return false; + } + + if( !IsVisible() && aFormatter.Print( 0, "N" ) < 0 ) + return false; + + if( m_shape & INVERT && aFormatter.Print( 0, "I" ) < 0 ) + return false; + + if( m_shape & CLOCK && aFormatter.Print( 0, "C" ) < 0 ) + return false; + + if( m_shape & LOWLEVEL_IN && aFormatter.Print( 0, "L" ) < 0 ) + return false; + + if( m_shape & LOWLEVEL_OUT && aFormatter.Print( 0, "V" ) < 0 ) + return false; + + if( m_shape & CLOCK_FALL && aFormatter.Print( 0, "F" ) < 0 ) + return false; + + if( m_shape & NONLOGIC && aFormatter.Print( 0, "X" ) < 0 ) + return false; + + if( aFormatter.Print( 0, "\n" ) < 0 ) + return false; + + ClearFlags( IS_CHANGED ); + + return true; +} + +#include <wx/tokenzr.h> + +bool LIB_PIN::Load( LINE_READER& aLineReader, wxString& aErrorMsg ) +{ + char pinAttrs[64]; + char pinOrient[64]; + char pinType[64]; + + *pinAttrs = 0; + + // We cannot use sscanf, at least on Windows, to parse the pin description. + // The reason is the pin name is free, and use UTF8 encoding. + // We encourtered issues (Windows specific) to read this name for some UTF8 + // cyrillic codes + // So, read the pin name (and num) after conversion from UTF8, and read the others + // parameters (in ASCII) using sscanf + + // the full line starts by "X ". The pin data starts at line + 2. + wxString utf8line = FROM_UTF8( aLineReader.Line() + 2 ); + wxStringTokenizer tokenizer( utf8line, wxT(" \n\r" ) ); + int prms_count = tokenizer.CountTokens(); + + if( prms_count < 11 ) + { + aErrorMsg.Printf( wxT( "pin had %d parameters of the required 11 or 12" ), prms_count ); + return false; + } + + // Extract the pinName (UTF8 encoded) + m_name = tokenizer.GetNextToken(); + + wxString tmp; + + // Extract the pinName (UTF8 encoded accepted, but should be only ASCII8.) + tmp = tokenizer.GetNextToken(); + SetPinNumFromString( tmp ); + + // Read other parameters, in pure ASCII + char line[1024]; + tmp = tokenizer.GetString(); + + unsigned len = tmp.Length(); + + if( len >= sizeof( line ) ) // Should not occur. + len = sizeof( line) - 1; + + strncpy( line, TO_UTF8( tmp ), len ); + line[len] = 0; + + int cnt = sscanf( line, "%d %d %d %63s %d %d %d %d %63s %63s", + &m_position.x, &m_position.y, &m_length, pinOrient, &m_numTextSize, + &m_nameTextSize, &m_Unit, &m_Convert, pinType, pinAttrs ); + + if( cnt != (prms_count - 2) ) + { + aErrorMsg.Printf( wxT( "pin parameters read issue" ) ); + return false; + } + + m_orientation = pinOrient[0] & 255; + + switch( *pinType & 255 ) + { + case 'I': + m_type = PIN_INPUT; + break; + + case 'O': + m_type = PIN_OUTPUT; + break; + + case 'B': + m_type = PIN_BIDI; + break; + + case 'T': + m_type = PIN_TRISTATE; + break; + + case 'P': + m_type = PIN_PASSIVE; + break; + + case 'U': + m_type = PIN_UNSPECIFIED; + break; + + case 'W': + m_type = PIN_POWER_IN; + break; + + case 'w': + m_type = PIN_POWER_OUT; + break; + + case 'C': + m_type = PIN_OPENCOLLECTOR; + break; + + case 'E': + m_type = PIN_OPENEMITTER; + break; + + case 'N': + m_type = PIN_NC; + break; + + default: + aErrorMsg.Printf( wxT( "unknown pin type [%c]" ), *pinType & 255 ); + return false; + } + + if( prms_count >= 12 ) /* Special Symbol defined */ + { + for( int j = strlen( pinAttrs ); j > 0; ) + { + switch( pinAttrs[--j] ) + { + case '~': + break; + + case 'N': + m_attributes |= PIN_INVISIBLE; + break; + + case 'I': + m_shape |= INVERT; + break; + + case 'C': + m_shape |= CLOCK; + break; + + case 'L': + m_shape |= LOWLEVEL_IN; + break; + + case 'V': + m_shape |= LOWLEVEL_OUT; + break; + + case 'F': + m_shape |= CLOCK_FALL; + break; + + case 'X': + m_shape |= NONLOGIC; + break; + + default: + aErrorMsg.Printf( wxT( "unknown pin attribute [%c]" ), pinAttrs[j] ); + return false; + } + } + } + + return true; +} + + +int LIB_PIN::GetPenSize() const +{ + return ( m_width == 0 ) ? GetDefaultLineThickness() : m_width; +} + + +void LIB_PIN::drawGraphic( EDA_DRAW_PANEL* aPanel, + wxDC* aDC, + const wxPoint& aOffset, + EDA_COLOR_T aColor, + GR_DRAWMODE aDrawMode, + void* aData, + const TRANSFORM& aTransform ) +{ + // aData is used here as a bitfield of flags. + uintptr_t flags = (uintptr_t) aData; + bool drawPinText = flags & PIN_DRAW_TEXTS; + bool drawPinDangling = flags & PIN_DRAW_DANGLING; + bool drawDanglingHidden = flags & PIN_DANGLING_HIDDEN; + + LIB_PART* Entry = GetParent(); + + /* Calculate pin orient taking in account the component orientation. */ + int orient = PinDrawOrient( aTransform ); + + /* Calculate the pin position */ + wxPoint pos1 = aTransform.TransformCoordinate( m_position ) + aOffset; + + // Invisible pins are only drawn on request. + // They are drawn in GetInvisibleItemColor(). + // in schematic, they are drawn only if m_showAllPins is true. + // In other windows, they are always drawn because we must see them. + if( ! IsVisible() ) + { + EDA_DRAW_FRAME* frame = NULL; + + if( aPanel && aPanel->GetParent() ) + frame = (EDA_DRAW_FRAME*)aPanel->GetParent(); + + if( frame && frame->IsType( FRAME_SCH ) && + ! ((SCH_EDIT_FRAME*)frame)->GetShowAllPins() ) + { + if( drawPinDangling && drawDanglingHidden ) + { + // Draw the target + DrawPinSymbol( aPanel, aDC, pos1, orient, aDrawMode, aColor, drawPinDangling, + /* aOnlyTarget */ true ); + } + return; + } + + aColor = GetInvisibleItemColor(); + } + + /* Drawing from the pin and the special symbol combination */ + DrawPinSymbol( aPanel, aDC, pos1, orient, aDrawMode, aColor, drawPinDangling ); + + if( drawPinText ) + { + DrawPinTexts( aPanel, aDC, pos1, orient, Entry->GetPinNameOffset(), + Entry->ShowPinNumbers(), Entry->ShowPinNames(), + aColor, aDrawMode ); + } + + /* Set to one (1) to draw bounding box around pin to validate bounding + * box calculation. */ +#if 0 + EDA_RECT bBox = GetBoundingBox(); + bBox.RevertYAxis(); + bBox = aTransform.TransformCoordinate( bBox ); + bBox.Move( aOffset ); + GRRect( aPanel ? aPanel->GetClipBox() : NULL, aDC, bBox, 0, LIGHTMAGENTA ); +#endif +} + + +void LIB_PIN::DrawPinSymbol( EDA_DRAW_PANEL* aPanel, + wxDC* aDC, + const wxPoint& aPinPos, + int aOrient, + GR_DRAWMODE aDrawMode, + EDA_COLOR_T aColor, + bool aDrawDangling, + bool aOnlyTarget ) +{ + int MapX1, MapY1, x1, y1; + int width = GetPenSize(); + int posX = aPinPos.x, posY = aPinPos.y, len = m_length; + EDA_RECT* clipbox = aPanel ? aPanel->GetClipBox() : NULL; + + EDA_COLOR_T color = GetLayerColor( LAYER_PIN ); + + if( aColor < 0 ) // Used normal color or selected color + { + if( IsSelected() ) + color = GetItemSelectedColor(); + } + else + color = aColor; + + GRSetDrawMode( aDC, aDrawMode ); + + MapX1 = MapY1 = 0; + x1 = posX; + y1 = posY; + + switch( aOrient ) + { + case PIN_UP: + y1 = posY - len; + MapY1 = 1; + break; + + case PIN_DOWN: + y1 = posY + len; + MapY1 = -1; + break; + + case PIN_LEFT: + x1 = posX - len; + MapX1 = 1; + break; + + case PIN_RIGHT: + x1 = posX + len; + MapX1 = -1; + break; + } + + // Draw the pin end target (active end of the pin) + BASE_SCREEN* screen = aPanel ? aPanel->GetScreen() : NULL; + #define NCSYMB_PIN_DIM TARGET_PIN_RADIUS + + // Draw but do not print the pin end target 1 pixel width + if( m_type != PIN_NC && ( screen == NULL || !screen->m_IsPrinting ) ) + { + if( aDrawDangling ) + GRCircle( clipbox, aDC, posX, posY, TARGET_PIN_RADIUS, 0, color ); + } + + if( aOnlyTarget ) + return; + + + if( m_shape & INVERT ) + { + const int radius = ExternalPinDecoSize( *this ); + GRCircle( clipbox, aDC, MapX1 * radius + x1, + MapY1 * radius + y1, + radius, width, color ); + + GRMoveTo( MapX1 * radius * 2 + x1, + MapY1 * radius * 2 + y1 ); + GRLineTo( clipbox, aDC, posX, posY, width, color ); + } + else if( m_shape & CLOCK_FALL ) /* an alternative for Inverted Clock */ + { + const int clock_size = InternalPinDecoSize( *this ); + if( MapY1 == 0 ) /* MapX1 = +- 1 */ + { + GRMoveTo( x1, y1 + clock_size ); + GRLineTo( clipbox, aDC, x1 + MapX1 * clock_size * 2, y1, + width, color ); + GRLineTo( clipbox, aDC, x1, y1 - clock_size, width, color ); + } + else /* MapX1 = 0 */ + { + GRMoveTo( x1 + clock_size, y1 ); + GRLineTo( clipbox, aDC, x1, y1 + MapY1 * clock_size * 2, + width, color ); + GRLineTo( clipbox, aDC, x1 - clock_size, y1, + width, color ); + } + GRMoveTo( MapX1 * clock_size * 2 + x1, MapY1 * clock_size * 2 + y1 ); + GRLineTo( clipbox, aDC, posX, posY, width, color ); + } + else + { + GRMoveTo( x1, y1 ); + GRLineTo( clipbox, aDC, posX, posY, width, color ); + } + + if( m_shape & CLOCK ) + { + const int clock_size = InternalPinDecoSize( *this ); + if( MapY1 == 0 ) /* MapX1 = +- 1 */ + { + GRMoveTo( x1, y1 + clock_size ); + GRLineTo( clipbox, aDC, x1 - MapX1 * clock_size * 2, y1, + width, color ); + GRLineTo( clipbox, aDC, x1, y1 - clock_size, + width, color ); + } + else /* MapX1 = 0 */ + { + GRMoveTo( x1 + clock_size, y1 ); + GRLineTo( clipbox, aDC, x1, y1 - MapY1 * clock_size * 2, + width, color ); + GRLineTo( clipbox, aDC, x1 - clock_size, y1, + width, color ); + } + } + + if( m_shape & LOWLEVEL_IN ) /* IEEE symbol "Active Low Input" */ + { + const int symbol_size = ExternalPinDecoSize( *this ); + if( MapY1 == 0 ) /* MapX1 = +- 1 */ + { + GRMoveTo( x1 + MapX1 * symbol_size * 2, y1 ); + GRLineTo( clipbox, aDC, + x1 + MapX1 * symbol_size * 2, y1 - symbol_size * 2, + width, color ); + GRLineTo( clipbox, aDC, x1, y1, width, color ); + } + else /* MapX1 = 0 */ + { + GRMoveTo( x1, y1 + MapY1 * symbol_size * 2 ); + GRLineTo( clipbox, aDC, x1 - symbol_size * 2, + y1 + MapY1 * symbol_size * 2, width, color ); + GRLineTo( clipbox, aDC, x1, y1, width, color ); + } + } + + + if( m_shape & LOWLEVEL_OUT ) /* IEEE symbol "Active Low Output" */ + { + const int symbol_size = ExternalPinDecoSize( *this ); + if( MapY1 == 0 ) /* MapX1 = +- 1 */ + { + GRMoveTo( x1, y1 - symbol_size * 2 ); + GRLineTo( clipbox, + aDC, + x1 + MapX1 * symbol_size * 2, + y1, + width, + color ); + } + else /* MapX1 = 0 */ + { + GRMoveTo( x1 - symbol_size * 2, y1 ); + GRLineTo( clipbox, aDC, x1, y1 + MapY1 * symbol_size * 2, + width, color ); + } + } + else if( m_shape & NONLOGIC ) /* NonLogic pin symbol */ + { + const int symbol_size = ExternalPinDecoSize( *this ); + GRMoveTo( x1 - (MapX1 + MapY1) * symbol_size, + y1 - (MapY1 - MapX1) * symbol_size ); + GRLineTo( clipbox, aDC, + x1 + (MapX1 + MapY1) * symbol_size, + y1 + (MapY1 - MapX1) * symbol_size, + width, color ); + GRMoveTo( x1 - (MapX1 - MapY1) * symbol_size, + y1 - (MapY1 + MapX1) * symbol_size ); + GRLineTo( clipbox, aDC, + x1 + (MapX1 - MapY1) * symbol_size, + y1 + (MapY1 + MapX1) * symbol_size, + width, color ); + } + + if( m_type == PIN_NC ) // Draw a N.C. symbol + { + GRLine( clipbox, aDC, + posX - NCSYMB_PIN_DIM, posY - NCSYMB_PIN_DIM, + posX + NCSYMB_PIN_DIM, posY + NCSYMB_PIN_DIM, + width, color ); + GRLine( clipbox, aDC, + posX + NCSYMB_PIN_DIM, posY - NCSYMB_PIN_DIM, + posX - NCSYMB_PIN_DIM, posY + NCSYMB_PIN_DIM, + width, color ); + } +} + + +void LIB_PIN::DrawPinTexts( EDA_DRAW_PANEL* panel, + wxDC* DC, + wxPoint& pin_pos, + int orient, + int TextInside, + bool DrawPinNum, + bool DrawPinName, + EDA_COLOR_T Color, + GR_DRAWMODE DrawMode ) +{ + if( !DrawPinName && !DrawPinNum ) + return; + + int x, y; + wxString StringPinNum; + + wxSize PinNameSize( m_nameTextSize, m_nameTextSize ); + wxSize PinNumSize( m_numTextSize, m_numTextSize ); + + int nameLineWidth = GetPenSize(); + + nameLineWidth = Clamp_Text_PenSize( nameLineWidth, m_nameTextSize, false ); + int numLineWidth = GetPenSize(); + numLineWidth = Clamp_Text_PenSize( numLineWidth, m_numTextSize, false ); + + GRSetDrawMode( DC, DrawMode ); + EDA_RECT* clipbox = panel? panel->GetClipBox() : NULL; + + /* Get the num and name colors */ + if( (Color < 0) && IsSelected() ) + Color = GetItemSelectedColor(); + + EDA_COLOR_T NameColor = Color == UNSPECIFIED_COLOR ? + GetLayerColor( LAYER_PINNAM ) : Color; + EDA_COLOR_T NumColor = Color == UNSPECIFIED_COLOR ? + GetLayerColor( LAYER_PINNUM ) : Color; + + /* Create the pin num string */ + PinStringNum( StringPinNum ); + + int x1 = pin_pos.x; + int y1 = pin_pos.y; + + switch( orient ) + { + case PIN_UP: + y1 -= m_length; + break; + + case PIN_DOWN: + y1 += m_length; + break; + + case PIN_LEFT: + x1 -= m_length; + break; + + case PIN_RIGHT: + x1 += m_length; + break; + } + + if( m_name.IsEmpty() ) + DrawPinName = false; + + if( TextInside ) // Draw the text inside, but the pin numbers outside. + { + if( (orient == PIN_LEFT) || (orient == PIN_RIGHT) ) + { + // It is an horizontal line + if( DrawPinName ) + { + if( orient == PIN_RIGHT ) + { + x = x1 + TextInside; + DrawGraphicText( clipbox, DC, wxPoint( x, y1 ), NameColor, + m_name, + TEXT_ORIENT_HORIZ, + PinNameSize, + GR_TEXT_HJUSTIFY_LEFT, + GR_TEXT_VJUSTIFY_CENTER, nameLineWidth, + false, false ); + } + else // Orient == PIN_LEFT + { + x = x1 - TextInside; + DrawGraphicText( clipbox, DC, wxPoint( x, y1 ), NameColor, + m_name, + TEXT_ORIENT_HORIZ, + PinNameSize, + GR_TEXT_HJUSTIFY_RIGHT, + GR_TEXT_VJUSTIFY_CENTER, nameLineWidth, + false, false ); + } + } + + if( DrawPinNum ) + { + DrawGraphicText( clipbox, DC, + wxPoint( (x1 + pin_pos.x) / 2, + y1 - TXTMARGE ), NumColor, + StringPinNum, + TEXT_ORIENT_HORIZ, PinNumSize, + GR_TEXT_HJUSTIFY_CENTER, + GR_TEXT_VJUSTIFY_BOTTOM, numLineWidth, + false, false ); + } + } + else /* Its a vertical line. */ + { + // Text is drawn from bottom to top (i.e. to negative value for Y axis) + if( orient == PIN_DOWN ) + { + y = y1 + TextInside; + + if( DrawPinName ) + DrawGraphicText( clipbox, DC, wxPoint( x1, y ), NameColor, + m_name, + TEXT_ORIENT_VERT, PinNameSize, + GR_TEXT_HJUSTIFY_RIGHT, + GR_TEXT_VJUSTIFY_CENTER, nameLineWidth, + false, false ); + + if( DrawPinNum ) + DrawGraphicText( clipbox, DC, + wxPoint( x1 - TXTMARGE, + (y1 + pin_pos.y) / 2 ), NumColor, + StringPinNum, + TEXT_ORIENT_VERT, PinNumSize, + GR_TEXT_HJUSTIFY_CENTER, + GR_TEXT_VJUSTIFY_BOTTOM, numLineWidth, + false, false ); + } + else /* PIN_UP */ + { + y = y1 - TextInside; + + if( DrawPinName ) + DrawGraphicText( clipbox, DC, wxPoint( x1, y ), NameColor, + m_name, + TEXT_ORIENT_VERT, PinNameSize, + GR_TEXT_HJUSTIFY_LEFT, + GR_TEXT_VJUSTIFY_CENTER, nameLineWidth, + false, false ); + + if( DrawPinNum ) + DrawGraphicText( clipbox, DC, + wxPoint( x1 - TXTMARGE, + (y1 + pin_pos.y) / 2 ), NumColor, + StringPinNum, + TEXT_ORIENT_VERT, PinNumSize, + GR_TEXT_HJUSTIFY_CENTER, + GR_TEXT_VJUSTIFY_BOTTOM, numLineWidth, + false, false ); + } + } + } + else /**** Draw num & text pin outside ****/ + { + if( (orient == PIN_LEFT) || (orient == PIN_RIGHT) ) + { + /* Its an horizontal line. */ + if( DrawPinName ) + { + x = (x1 + pin_pos.x) / 2; + DrawGraphicText( clipbox, DC, wxPoint( x, y1 - TXTMARGE ), + NameColor, m_name, + TEXT_ORIENT_HORIZ, PinNameSize, + GR_TEXT_HJUSTIFY_CENTER, + GR_TEXT_VJUSTIFY_BOTTOM, nameLineWidth, + false, false ); + } + if( DrawPinNum ) + { + x = (x1 + pin_pos.x) / 2; + DrawGraphicText( clipbox, DC, wxPoint( x, y1 + TXTMARGE ), + NumColor, StringPinNum, + TEXT_ORIENT_HORIZ, PinNumSize, + GR_TEXT_HJUSTIFY_CENTER, + GR_TEXT_VJUSTIFY_TOP, numLineWidth, + false, false ); + } + } + else /* Its a vertical line. */ + { + if( DrawPinName ) + { + y = (y1 + pin_pos.y) / 2; + DrawGraphicText( clipbox, DC, wxPoint( x1 - TXTMARGE, y ), + NameColor, m_name, + TEXT_ORIENT_VERT, PinNameSize, + GR_TEXT_HJUSTIFY_CENTER, + GR_TEXT_VJUSTIFY_BOTTOM, nameLineWidth, + false, false ); + } + + if( DrawPinNum ) + { + DrawGraphicText( clipbox, DC, + wxPoint( x1 + TXTMARGE, (y1 + pin_pos.y) / 2 ), + NumColor, StringPinNum, + TEXT_ORIENT_VERT, PinNumSize, + GR_TEXT_HJUSTIFY_CENTER, + GR_TEXT_VJUSTIFY_TOP, numLineWidth, + false, false ); + } + } + } +} + + +void LIB_PIN::PlotSymbol( PLOTTER* aPlotter, const wxPoint& aPosition, int aOrientation ) +{ + int MapX1, MapY1, x1, y1; + EDA_COLOR_T color = GetLayerColor( LAYER_PIN ); + + aPlotter->SetColor( color ); + aPlotter->SetCurrentLineWidth( GetPenSize() ); + + MapX1 = MapY1 = 0; + x1 = aPosition.x; y1 = aPosition.y; + + switch( aOrientation ) + { + case PIN_UP: + y1 = aPosition.y - m_length; + MapY1 = 1; + break; + + case PIN_DOWN: + y1 = aPosition.y + m_length; + MapY1 = -1; + break; + + case PIN_LEFT: + x1 = aPosition.x - m_length; + MapX1 = 1; + break; + + case PIN_RIGHT: + x1 = aPosition.x + m_length; + MapX1 = -1; + break; + } + + if( m_shape & INVERT ) + { + const int radius = ExternalPinDecoSize( *this ); + aPlotter->Circle( wxPoint( MapX1 * radius + x1, + MapY1 * radius + y1 ), + radius * 2, // diameter + NO_FILL, // fill option + GetPenSize() ); // width + + aPlotter->MoveTo( wxPoint( MapX1 * radius * 2 + x1, + MapY1 * radius * 2 + y1 ) ); + aPlotter->FinishTo( aPosition ); + } + else if( m_shape & CLOCK_FALL ) + { + const int clock_size = InternalPinDecoSize( *this ); + if( MapY1 == 0 ) /* MapX1 = +- 1 */ + { + aPlotter->MoveTo( wxPoint( x1, y1 + clock_size ) ); + aPlotter->LineTo( wxPoint( x1 + MapX1 * clock_size * 2, y1 ) ); + aPlotter->FinishTo( wxPoint( x1, y1 - clock_size ) ); + } + else /* MapX1 = 0 */ + { + aPlotter->MoveTo( wxPoint( x1 + clock_size, y1 ) ); + aPlotter->LineTo( wxPoint( x1, y1 + MapY1 * clock_size * 2 ) ); + aPlotter->FinishTo( wxPoint( x1 - clock_size, y1 ) ); + } + + aPlotter->MoveTo( wxPoint( MapX1 * clock_size * 2 + x1, + MapY1 * clock_size * 2 + y1 ) ); + aPlotter->FinishTo( aPosition ); + } + else + { + aPlotter->MoveTo( wxPoint( x1, y1 ) ); + aPlotter->FinishTo( aPosition ); + } + + if( m_shape & CLOCK ) + { + const int clock_size = InternalPinDecoSize( *this ); + if( MapY1 == 0 ) /* MapX1 = +- 1 */ + { + aPlotter->MoveTo( wxPoint( x1, y1 + clock_size ) ); + aPlotter->LineTo( wxPoint( x1 - MapX1 * clock_size * 2, y1 ) ); + aPlotter->FinishTo( wxPoint( x1, y1 - clock_size ) ); + } + else /* MapX1 = 0 */ + { + aPlotter->MoveTo( wxPoint( x1 + clock_size, y1 ) ); + aPlotter->LineTo( wxPoint( x1, y1 - MapY1 * clock_size * 2 ) ); + aPlotter->FinishTo( wxPoint( x1 - clock_size, y1 ) ); + } + } + + if( m_shape & LOWLEVEL_IN ) /* IEEE symbol "Active Low Input" */ + { + const int symbol_size = ExternalPinDecoSize( *this ); + + if( MapY1 == 0 ) /* MapX1 = +- 1 */ + { + aPlotter->MoveTo( wxPoint( x1 + MapX1 * symbol_size * 2, y1 ) ); + aPlotter->LineTo( wxPoint( x1 + MapX1 * symbol_size * 2, + y1 - symbol_size * 2 ) ); + aPlotter->FinishTo( wxPoint( x1, y1 ) ); + } + else /* MapX1 = 0 */ + { + aPlotter->MoveTo( wxPoint( x1, y1 + MapY1 * symbol_size * 2 ) ); + aPlotter->LineTo( wxPoint( x1 - symbol_size * 2, + y1 + MapY1 * symbol_size * 2 ) ); + aPlotter->FinishTo( wxPoint( x1, y1 ) ); + } + } + + + if( m_shape & LOWLEVEL_OUT ) /* IEEE symbol "Active Low Output" */ + { + const int symbol_size = ExternalPinDecoSize( *this ); + + if( MapY1 == 0 ) /* MapX1 = +- 1 */ + { + aPlotter->MoveTo( wxPoint( x1, y1 - symbol_size * 2 ) ); + aPlotter->FinishTo( wxPoint( x1 + MapX1 * symbol_size * 2, y1 ) ); + } + else /* MapX1 = 0 */ + { + aPlotter->MoveTo( wxPoint( x1 - symbol_size * 2, y1 ) ); + aPlotter->FinishTo( wxPoint( x1, y1 + MapY1 * symbol_size * 2 ) ); + } + } + else if( m_shape & NONLOGIC ) /* NonLogic pin symbol */ + { + const int symbol_size = ExternalPinDecoSize( *this ); + aPlotter->MoveTo( wxPoint( x1 - (MapX1 + MapY1) * symbol_size, + y1 - (MapY1 - MapX1) * symbol_size ) ); + aPlotter->FinishTo( wxPoint( x1 + (MapX1 + MapY1) * symbol_size, + y1 + (MapY1 - MapX1) * symbol_size ) ); + aPlotter->MoveTo( wxPoint( x1 - (MapX1 - MapY1) * symbol_size, + y1 - (MapY1 + MapX1) * symbol_size ) ); + aPlotter->FinishTo( wxPoint( x1 + (MapX1 - MapY1) * symbol_size, + y1 + (MapY1 + MapX1) * symbol_size ) ); + } + if( m_type == PIN_NC ) // Draw a N.C. symbol + { + const int ex1 = aPosition.x; + const int ey1 = aPosition.y; + aPlotter->MoveTo( wxPoint( ex1 - NCSYMB_PIN_DIM, ey1 - NCSYMB_PIN_DIM ) ); + aPlotter->FinishTo( wxPoint( ex1 + NCSYMB_PIN_DIM, ey1 + NCSYMB_PIN_DIM ) ); + aPlotter->MoveTo( wxPoint( ex1 + NCSYMB_PIN_DIM, ey1 - NCSYMB_PIN_DIM ) ); + aPlotter->FinishTo( wxPoint( ex1 - NCSYMB_PIN_DIM, ey1 + NCSYMB_PIN_DIM ) ); + } +} + + +void LIB_PIN::PlotPinTexts( PLOTTER* plotter, wxPoint& pin_pos, int orient, + int TextInside, bool DrawPinNum, + bool DrawPinName, int aWidth ) +{ + if( m_name.IsEmpty() || m_name == wxT( "~" ) ) + DrawPinName = false; + + /* Create the pin num string */ + wxString StringPinNum; + PinStringNum( StringPinNum ); + + if( StringPinNum.IsEmpty() ) + DrawPinNum = false; + + if( !DrawPinNum && !DrawPinName ) + return; + + int x, y; + wxSize PinNameSize = wxSize( m_nameTextSize, m_nameTextSize ); + wxSize PinNumSize = wxSize( m_numTextSize, m_numTextSize ); + + /* Get the num and name colors */ + EDA_COLOR_T NameColor = GetLayerColor( LAYER_PINNAM ); + EDA_COLOR_T NumColor = GetLayerColor( LAYER_PINNUM ); + + int x1 = pin_pos.x; + int y1 = pin_pos.y; + + switch( orient ) + { + case PIN_UP: + y1 -= m_length; + break; + + case PIN_DOWN: + y1 += m_length; + break; + + case PIN_LEFT: + x1 -= m_length; + break; + + case PIN_RIGHT: + x1 += m_length; + break; + } + + /* Draw the text inside, but the pin numbers outside. */ + if( TextInside ) + { + if( (orient == PIN_LEFT) || (orient == PIN_RIGHT) ) /* Its an horizontal line. */ + { + if( DrawPinName ) + { + if( orient == PIN_RIGHT ) + { + x = x1 + TextInside; + plotter->Text( wxPoint( x, y1 ), NameColor, + m_name, + TEXT_ORIENT_HORIZ, + PinNameSize, + GR_TEXT_HJUSTIFY_LEFT, + GR_TEXT_VJUSTIFY_CENTER, + aWidth, false, false ); + } + else // orient == PIN_LEFT + { + x = x1 - TextInside; + + if( DrawPinName ) + plotter->Text( wxPoint( x, y1 ), + NameColor, m_name, TEXT_ORIENT_HORIZ, + PinNameSize, + GR_TEXT_HJUSTIFY_RIGHT, + GR_TEXT_VJUSTIFY_CENTER, + aWidth, false, false ); + } + } + if( DrawPinNum ) + { + plotter->Text( wxPoint( (x1 + pin_pos.x) / 2, y1 - TXTMARGE ), + NumColor, StringPinNum, + TEXT_ORIENT_HORIZ, PinNumSize, + GR_TEXT_HJUSTIFY_CENTER, + GR_TEXT_VJUSTIFY_BOTTOM, + aWidth, false, false ); + } + } + else /* Its a vertical line. */ + { + if( orient == PIN_DOWN ) + { + y = y1 + TextInside; + + if( DrawPinName ) + plotter->Text( wxPoint( x1, y ), NameColor, + m_name, + TEXT_ORIENT_VERT, PinNameSize, + GR_TEXT_HJUSTIFY_RIGHT, + GR_TEXT_VJUSTIFY_CENTER, + aWidth, false, false ); + + if( DrawPinNum ) + { + plotter->Text( wxPoint( x1 - TXTMARGE, (y1 + pin_pos.y) / 2 ), + NumColor, StringPinNum, + TEXT_ORIENT_VERT, PinNumSize, + GR_TEXT_HJUSTIFY_CENTER, + GR_TEXT_VJUSTIFY_BOTTOM, + aWidth, false, false ); + } + } + else /* PIN_UP */ + { + y = y1 - TextInside; + + if( DrawPinName ) + plotter->Text( wxPoint( x1, y ), NameColor, + m_name, + TEXT_ORIENT_VERT, PinNameSize, + GR_TEXT_HJUSTIFY_LEFT, + GR_TEXT_VJUSTIFY_CENTER, + aWidth, false, false ); + + if( DrawPinNum ) + { + plotter->Text( wxPoint( x1 - TXTMARGE, (y1 + pin_pos.y) / 2 ), + NumColor, StringPinNum, + TEXT_ORIENT_VERT, PinNumSize, + GR_TEXT_HJUSTIFY_CENTER, + GR_TEXT_VJUSTIFY_BOTTOM, + aWidth, false, false ); + } + } + } + } + else /* Draw num & text pin outside */ + { + if( (orient == PIN_LEFT) || (orient == PIN_RIGHT) ) + { + /* Its an horizontal line. */ + if( DrawPinName ) + { + x = (x1 + pin_pos.x) / 2; + plotter->Text( wxPoint( x, y1 - TXTMARGE ), + NameColor, m_name, + TEXT_ORIENT_HORIZ, PinNameSize, + GR_TEXT_HJUSTIFY_CENTER, + GR_TEXT_VJUSTIFY_BOTTOM, + aWidth, false, false ); + } + + if( DrawPinNum ) + { + x = ( x1 + pin_pos.x ) / 2; + plotter->Text( wxPoint( x, y1 + TXTMARGE ), + NumColor, StringPinNum, + TEXT_ORIENT_HORIZ, PinNumSize, + GR_TEXT_HJUSTIFY_CENTER, + GR_TEXT_VJUSTIFY_TOP, + aWidth, false, false ); + } + } + else /* Its a vertical line. */ + { + if( DrawPinName ) + { + y = ( y1 + pin_pos.y ) / 2; + plotter->Text( wxPoint( x1 - TXTMARGE, y ), + NameColor, m_name, + TEXT_ORIENT_VERT, PinNameSize, + GR_TEXT_HJUSTIFY_CENTER, + GR_TEXT_VJUSTIFY_BOTTOM, + aWidth, false, false ); + } + + if( DrawPinNum ) + { + plotter->Text( wxPoint( x1 + TXTMARGE, ( y1 + pin_pos.y ) / 2 ), + NumColor, StringPinNum, + TEXT_ORIENT_VERT, PinNumSize, + GR_TEXT_HJUSTIFY_CENTER, + GR_TEXT_VJUSTIFY_TOP, + aWidth, false, false ); + } + } + } +} + + +wxPoint LIB_PIN::PinEndPoint() const +{ + wxPoint pos = m_position; + + switch( m_orientation ) + { + case PIN_UP: + pos.y += m_length; + break; + + case PIN_DOWN: + pos.y -= m_length; + break; + + case PIN_LEFT: + pos.x -= m_length; + break; + + case PIN_RIGHT: + pos.x += m_length; + break; + } + + return pos; +} + + +int LIB_PIN::PinDrawOrient( const TRANSFORM& aTransform ) const +{ + int orient; + wxPoint end; // position of pin end starting at 0,0 according to its orientation, length = 1 + + switch( m_orientation ) + { + case PIN_UP: + end.y = 1; + break; + + case PIN_DOWN: + end.y = -1; + break; + + case PIN_LEFT: + end.x = -1; + break; + + case PIN_RIGHT: + end.x = 1; + break; + } + + // = pos of end point, according to the component orientation + end = aTransform.TransformCoordinate( end ); + orient = PIN_UP; + + if( end.x == 0 ) + { + if( end.y > 0 ) + orient = PIN_DOWN; + } + else + { + orient = PIN_RIGHT; + + if( end.x < 0 ) + orient = PIN_LEFT; + } + + return orient; +} + + +void LIB_PIN::PinStringNum( wxString& aStringBuffer ) const +{ + aStringBuffer = PinStringNum( m_number ); +} + + +wxString LIB_PIN::PinStringNum( long aPinNum ) +{ + char ascii_buf[5]; + + memcpy( ascii_buf, &aPinNum, 4 ); + ascii_buf[4] = 0; + + wxString buffer = FROM_UTF8( ascii_buf ); + + return buffer; +} + + +void LIB_PIN::SetPinNumFromString( wxString& buffer ) +{ + char ascii_buf[4]; + unsigned ii, len = buffer.Len(); + + ascii_buf[0] = ascii_buf[1] = ascii_buf[2] = ascii_buf[3] = 0; + + if( len > 4 ) + len = 4; + + for( ii = 0; ii < len; ii++ ) + { + ascii_buf[ii] = buffer.GetChar( ii ); + ascii_buf[ii] &= 0xFF; + } + + strncpy( (char*) &m_number, ascii_buf, 4 ); +} + + +EDA_ITEM* LIB_PIN::Clone() const +{ + return new LIB_PIN( *this ); +} + + +int LIB_PIN::compare( const LIB_ITEM& other ) const +{ + wxASSERT( other.Type() == LIB_PIN_T ); + + const LIB_PIN* tmp = (LIB_PIN*) &other; + + if( m_number != tmp->m_number ) + return m_number - tmp->m_number; + + int result = m_name.CmpNoCase( tmp->m_name ); + + if( result != 0 ) + return result; + + if( m_position.x != tmp->m_position.x ) + return m_position.x - tmp->m_position.x; + + if( m_position.y != tmp->m_position.y ) + return m_position.y - tmp->m_position.y; + + return 0; +} + + +void LIB_PIN::SetOffset( const wxPoint& aOffset ) +{ + m_position += aOffset; +} + + +bool LIB_PIN::Inside( EDA_RECT& rect ) const +{ + wxPoint end = PinEndPoint(); + + return rect.Contains( m_position.x, -m_position.y ) || rect.Contains( end.x, -end.y ); +} + + +void LIB_PIN::Move( const wxPoint& newPosition ) +{ + if( m_position != newPosition ) + { + m_position = newPosition; + SetModified(); + } +} + + +void LIB_PIN::MirrorHorizontal( const wxPoint& center ) +{ + m_position.x -= center.x; + m_position.x *= -1; + m_position.x += center.x; + + if( m_orientation == PIN_RIGHT ) + m_orientation = PIN_LEFT; + else if( m_orientation == PIN_LEFT ) + m_orientation = PIN_RIGHT; +} + +void LIB_PIN::MirrorVertical( const wxPoint& center ) +{ + m_position.y -= center.y; + m_position.y *= -1; + m_position.y += center.y; + + if( m_orientation == PIN_UP ) + m_orientation = PIN_DOWN; + else if( m_orientation == PIN_DOWN ) + m_orientation = PIN_UP; +} + +void LIB_PIN::Rotate( const wxPoint& center, bool aRotateCCW ) +{ + int rot_angle = aRotateCCW ? -900 : 900; + + RotatePoint( &m_position, center, rot_angle ); + + if( aRotateCCW ) + { + switch( m_orientation ) + { + case PIN_RIGHT: + m_orientation = PIN_UP; + break; + + case PIN_UP: + m_orientation = PIN_LEFT; + break; + case PIN_LEFT: + m_orientation = PIN_DOWN; + break; + + case PIN_DOWN: + m_orientation = PIN_RIGHT; + break; + } + } + else + { + switch( m_orientation ) + { + case PIN_RIGHT: + m_orientation = PIN_DOWN; + break; + + case PIN_UP: + m_orientation = PIN_RIGHT; + break; + case PIN_LEFT: + m_orientation = PIN_UP; + break; + + case PIN_DOWN: + m_orientation = PIN_LEFT; + break; + } + } +} + + +void LIB_PIN::Plot( PLOTTER* plotter, const wxPoint& offset, bool fill, + const TRANSFORM& aTransform ) +{ + if( ! IsVisible() ) + return; + + int orient = PinDrawOrient( aTransform ); + + wxPoint pos = aTransform.TransformCoordinate( m_position ) + offset; + + PlotSymbol( plotter, pos, orient ); + PlotPinTexts( plotter, pos, orient, GetParent()->GetPinNameOffset(), + GetParent()->ShowPinNumbers(), GetParent()->ShowPinNames(), + GetPenSize() ); +} + + +void LIB_PIN::SetWidth( int aWidth ) +{ + if( m_width != aWidth ) + { + m_width = aWidth; + SetModified(); + } +} + + +void LIB_PIN::GetMsgPanelInfo( MSG_PANEL_ITEMS& aList ) +{ + wxString text; + + LIB_ITEM::GetMsgPanelInfo( aList ); + + aList.push_back( MSG_PANEL_ITEM( _( "Name" ), m_name, DARKCYAN ) ); + + if( m_number == 0 ) + text = wxT( "?" ); + else + PinStringNum( text ); + + aList.push_back( MSG_PANEL_ITEM( _( "Number" ), text, DARKCYAN ) ); + + aList.push_back( MSG_PANEL_ITEM( _( "Type" ), + LIB_PIN::GetElectricalTypeName( m_type ), + RED ) ); + + int styleCodeIndex = GetStyleCodeIndex( m_shape ); + + if( styleCodeIndex >= 0 ) + text = getPinStyleName( styleCodeIndex ); + else + text = wxT( "?" ); + + aList.push_back( MSG_PANEL_ITEM( _( "Style" ), text, BLUE ) ); + + if( IsVisible() ) + text = _( "Yes" ); + else + text = _( "No" ); + + aList.push_back( MSG_PANEL_ITEM( _( "Visible" ), text, DARKGREEN ) ); + + // Display pin length + text = StringFromValue( g_UserUnit, m_length, true ); + aList.push_back( MSG_PANEL_ITEM( _( "Length" ), text, MAGENTA ) ); + + text = getPinOrientationName( (unsigned) GetOrientationCodeIndex( m_orientation ) ); + aList.push_back( MSG_PANEL_ITEM( _( "Orientation" ), text, DARKMAGENTA ) ); +} + + +const EDA_RECT LIB_PIN::GetBoundingBox() const +{ + LIB_PART* entry = (LIB_PART* ) m_Parent; + EDA_RECT bbox; + wxPoint begin; + wxPoint end; + int nameTextOffset = 0; + bool showName = !m_name.IsEmpty() && (m_name != wxT( "~" )); + bool showNum = m_number != 0; + int minsizeV = TARGET_PIN_RADIUS; + + + if( entry ) + { + if( entry->ShowPinNames() ) + nameTextOffset = entry->GetPinNameOffset(); + else + showName = false; + + showNum = entry->ShowPinNumbers(); + } + + // First, calculate boundary box corners position + int numberTextLength = showNum ? m_numTextSize * GetNumberString().Len() : 0; + + // Actual text height is bigger than text size + int numberTextHeight = showNum ? KiROUND( m_numTextSize * 1.1 ) : 0; + + if( m_shape & INVERT ) + minsizeV = std::max( TARGET_PIN_RADIUS, ExternalPinDecoSize( *this ) ); + + // calculate top left corner position + // for the default pin orientation (PIN_RIGHT) + begin.y = std::max( minsizeV, numberTextHeight + TXTMARGE ); + begin.x = std::min( -TARGET_PIN_RADIUS, m_length - (numberTextLength / 2) ); + + // calculate bottom right corner position and adjust top left corner position + int nameTextLength = 0; + int nameTextHeight = 0; + + if( showName ) + { + int length = m_name.Len(); + + // Don't count the line over text symbol. + if( m_name.Left( 1 ) == wxT( "~" ) ) + length -= 1; + + nameTextLength = ( m_nameTextSize * length ) + nameTextOffset; + + // Actual text height are bigger than text size + nameTextHeight = KiROUND( m_nameTextSize * 1.1 ) + TXTMARGE; + } + + if( nameTextOffset ) // for values > 0, pin name is inside the body + { + end.x = m_length + nameTextLength; + end.y = std::min( -minsizeV, -nameTextHeight / 2 ); + } + else // if value == 0: + // pin name is outside the body, and above the pin line + // pin num is below the pin line + { + end.x = std::max(m_length, nameTextLength); + end.y = -begin.y; + begin.y = std::max( minsizeV, nameTextHeight ); + } + + // Now, calculate boundary box corners position for the actual pin orientation + int orient = PinDrawOrient( DefaultTransform ); + + /* Calculate the pin position */ + switch( orient ) + { + case PIN_UP: + // Pin is rotated and texts positions are mirrored + RotatePoint( &begin, wxPoint( 0, 0 ), -900 ); + RotatePoint( &end, wxPoint( 0, 0 ), -900 ); + break; + + case PIN_DOWN: + RotatePoint( &begin, wxPoint( 0, 0 ), 900 ); + RotatePoint( &end, wxPoint( 0, 0 ), 900 ); + begin.x = -begin.x; + end.x = -end.x; + break; + + case PIN_LEFT: + begin.x = -begin.x; + end.x = -end.x; + break; + + case PIN_RIGHT: + break; + } + + begin += m_position; + end += m_position; + + bbox.SetOrigin( begin ); + bbox.SetEnd( end ); + bbox.Normalize(); + bbox.Inflate( ( GetPenSize() / 2 ) + 1 ); + + // Draw Y axis is reversed in schematic: + bbox.RevertYAxis(); + + return bbox; +} + + +wxArrayString LIB_PIN::GetOrientationNames( void ) +{ + wxArrayString tmp; + + for( unsigned ii = 0; ii < PIN_ORIENTATION_CNT; ii++ ) + tmp.Add( getPinOrientationName( ii ) ); + + return tmp; +} + + +int LIB_PIN::GetOrientationCode( int index ) +{ + if( index >= 0 && index < (int) PIN_ORIENTATION_CNT ) + return pin_orientation_codes[ index ]; + + return PIN_RIGHT; +} + + +int LIB_PIN::GetOrientationCodeIndex( int code ) +{ + size_t i; + + for( i = 0; i < PIN_ORIENTATION_CNT; i++ ) + { + if( pin_orientation_codes[i] == code ) + return (int) i; + } + + return wxNOT_FOUND; +} + + +void LIB_PIN::Rotate() +{ + int orient = PIN_RIGHT; + + switch( GetOrientation() ) + { + case PIN_UP: + orient = PIN_LEFT; + break; + + case PIN_DOWN: + orient = PIN_RIGHT; + break; + + case PIN_LEFT: + orient = PIN_DOWN; + break; + + case PIN_RIGHT: + orient = PIN_UP; + break; + } + + // Set the new orientation + SetOrientation( orient ); +} + + +wxArrayString LIB_PIN::GetStyleNames( void ) +{ + wxArrayString tmp; + + for( unsigned ii = 0; ii < PIN_STYLE_CNT; ii++ ) + tmp.Add( getPinStyleName( ii ) ); + + return tmp; +} + + +int LIB_PIN::GetStyleCode( int index ) +{ + if( index >= 0 && index < (int) PIN_STYLE_CNT ) + return pin_style_codes[ index ]; + + return NONE; +} + + +int LIB_PIN::GetStyleCodeIndex( int code ) +{ + size_t i; + + for( i = 0; i < PIN_STYLE_CNT; i++ ) + { + if( pin_style_codes[i] == code ) + return (int) i; + } + + return wxNOT_FOUND; +} + + +wxArrayString LIB_PIN::GetElectricalTypeNames( void ) +{ + wxArrayString tmp; + + for( unsigned ii = 0; ii < PIN_ELECTRICAL_TYPE_CNT; ii++ ) + tmp.Add( LIB_PIN::GetElectricalTypeName( ii ) ); + + return tmp; +} + + +const BITMAP_DEF* LIB_PIN::GetElectricalTypeSymbols() +{ + return iconsPinsElectricalType; +} + + +const BITMAP_DEF* LIB_PIN::GetOrientationSymbols() +{ + return iconsPinsOrientations; +} + + +const BITMAP_DEF* LIB_PIN::GetStyleSymbols() +{ + return iconsPinsShapes; +} + + +BITMAP_DEF LIB_PIN::GetMenuImage() const +{ + return iconsPinsElectricalType[m_type]; +} + + +wxString LIB_PIN::GetSelectMenuText() const +{ + wxString tmp; + wxString style; + + int styleCode = GetStyleCodeIndex( m_shape ); + + if( styleCode >= 0 ) + style = getPinStyleName( styleCode ); + else + style = wxT( "?" ); + + tmp.Printf( _( "Pin %s, %s, %s" ), + GetChars( GetNumberString() ), + GetChars( GetElectricalTypeName() ), + GetChars( style ) + ); + return tmp; +} + + +bool LIB_PIN::Matches( wxFindReplaceData& aSearchData, void* aAuxData, wxPoint* aFindLocation ) +{ + wxLogTrace( traceFindItem, wxT( " item " ) + GetSelectMenuText() ); + + // Note: this will have to be modified if we add find and replace capability to the + // compoment library editor. Otherwise, you wont be able to replace pin text. + if( !( aSearchData.GetFlags() & FR_SEARCH_ALL_PINS ) + || ( aSearchData.GetFlags() & FR_SEARCH_REPLACE ) ) + return false; + + wxLogTrace( traceFindItem, wxT( " child item " ) + GetSelectMenuText() ); + + if( EDA_ITEM::Matches( GetName(), aSearchData ) + || EDA_ITEM::Matches( GetNumberString(), aSearchData ) ) + { + if( aFindLocation ) + *aFindLocation = GetBoundingBox().Centre(); + + return true; + } + + return false; +} + + +#if defined(DEBUG) + +void LIB_PIN::Show( int nestLevel, std::ostream& os ) const +{ + NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str() + << " num=\"" << GetNumberString().mb_str() + << '"' << "/>\n"; + +// NestedSpace( nestLevel, os ) << "</" << GetClass().Lower().mb_str() << ">\n"; +} + +#endif |