eeschema: code cleaning (2f99ef29) · Commits · Elphel / kicad-source-mirror

eeschema/CMakeLists.txt

+2 −0

Original line number	Diff line number	Diff line
		@@ -14,9 +14,11 @@ set(EESCHEMA_SRCS
		bus-wire-junction.cpp
		class_drawsheet.cpp
		class_hierarchical_PIN_sheet.cpp
		class_pin.cpp
		class_schematic_items.cpp
		class_screen.cpp
		class_text-label.cpp
		classes_body_items.cpp
		cleanup.cpp
		component_class.cpp
		controle.cpp

eeschema/block_libedit.cpp

+6 −6

Original line number	Diff line number	Diff line
		@@ -139,8 +139,8 @@ int MarkItemsInBloc( EDA_LibComponentStruct* LibComponent,

		case COMPONENT_POLYLINE_DRAW_TYPE:
		{
		int ii, imax = ( (LibDrawPolyline) item )->n 2;
		int* ptpoly = ( (LibDrawPolyline*) item )->PolyList;
		int ii, imax = ( (LibDrawPolyline) item )->m_CornersCount 2;
		int* ptpoly = ( (LibDrawPolyline*) item )->m_PolyList;
		for( ii = 0; ii < imax; ii += 2 )
		{
		pos.x = ptpoly[ii]; pos.y = -ptpoly[ii + 1];
		@@ -577,8 +577,8 @@ void MoveMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset )

		case COMPONENT_POLYLINE_DRAW_TYPE:
		{
		int ii, imax = ( (LibDrawPolyline) item )->n 2;
		int* ptpoly = ( (LibDrawPolyline*) item )->PolyList;
		int ii, imax = ( (LibDrawPolyline) item )->m_CornersCount 2;
		int* ptpoly = ( (LibDrawPolyline*) item )->m_PolyList;
		for( ii = 0; ii < imax; ii += 2 )
		{
		ptpoly[ii] += offset.x;
		@@ -689,8 +689,8 @@ void MirrorMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset )

		case COMPONENT_POLYLINE_DRAW_TYPE:
		{
		int ii, imax = ( (LibDrawPolyline) item )->n 2;
		int* ptpoly = ( (LibDrawPolyline*) item )->PolyList;
		int ii, imax = ( (LibDrawPolyline) item )->m_CornersCount 2;
		int* ptpoly = ( (LibDrawPolyline*) item )->m_PolyList;
		for( ii = 0; ii < imax; ii += 2 )
		{
		SETMIRROR( ptpoly[ii] );

eeschema/class_library.h

0 → 100644

+135 −0

Original line number	Diff line number	Diff line
		/****************************************************************/
		/* Headers fo library definition and lib component definitions */
		/****************************************************************/

		#ifndef CLASS_LIBRARY_H
		#define CLASS_LIBRARY_H


		/* Types for components in libraries
		* components can be a true component or an alias of a true component.
		*/
		enum LibrEntryType {
		ROOT, /* This is a true component standard EDA_LibComponentStruct */
		ALIAS /* This is an alias of a true component */
		};

		/* values for member .m_Options */
		enum LibrEntryOptions {
		ENTRY_NORMAL, // Libentry is a standard component (real or alias)
		ENTRY_POWER // Libentry is a power symbol
		};


		/******************************/
		/* Classe to handle a library */
		/******************************/

		class LibraryStruct
		{
		public:
		int m_Type; /* type indicator */
		wxString m_Name; /* Short Name of the loaded library (without path). */
		wxString m_FullFileName; /* Full File Name (with path) of library. */
		wxString m_Header; /* first line of loaded library. */
		int m_NumOfParts; /* Number of parts this library has. */
		PriorQue* m_Entries; /* Parts themselves are saved here. */
		LibraryStruct* m_Pnext; /* Point on next lib in chain. */
		int m_Modified; /* flag indicateur d'edition */
		int m_Size; // Size in bytes (for statistics)
		unsigned long m_TimeStamp; // Signature temporelle
		int m_Flags; // variable used in some functions
		bool m_IsLibCache; /* False for the "standard" libraries,
		* True for the library cache */

		public:
		LibraryStruct( int type, const wxString& name, const wxString& fullname );
		~LibraryStruct();
		bool WriteHeader( FILE* file );
		bool ReadHeader( FILE* file, int* LineNum );
		};


		#include "classes_body_items.h"


		/* basic class to describe components in libraries (true component or alias), non used directly */
		class LibCmpEntry : public EDA_BaseStruct
		{
		public:
		LibrEntryType Type; /* Type = ROOT;
		* = ALIAS pour struct LibraryAliasType */
		LibDrawField m_Name; // name (74LS00 ..) in lib ( = VALUE )
		wxString m_Doc; /* documentation for info */
		wxString m_KeyWord; /* keyword list (used to select a group of components by keyword) */
		wxString m_DocFile; /* Associed doc filename */
		LibrEntryOptions m_Options; // special features (i.e. Entry is a POWER)

		public:
		LibCmpEntry( LibrEntryType CmpType, const wxChar* CmpName );
		virtual ~LibCmpEntry();
		virtual wxString GetClass() const
		{
		return wxT( "LibCmpEntry" );
		}


		bool WriteDescr( FILE* File );
		};


		/*********************************************/
		/* class to handle an usual component in lib */
		/*********************************************/
		class EDA_LibComponentStruct : public LibCmpEntry
		{
		public:
		LibDrawField m_Prefix; /* Prefix ( U, IC ... ) = REFERENCE */
		wxArrayString m_AliasList; /* ALIAS list for the component */
		wxArrayString m_FootprintList; /* list of suitable footprint names for the component (wildcard names accepted)*/
		int m_UnitCount; /* Units (or sections) per package */
		bool m_UnitSelectionLocked; // True if units are differents and their selection is locked
		// (i.e. if part A cannot be automatically changed in part B
		int m_TextInside; /* if 0: pin name drawn on the pin itself
		* if > 0 pin name drawn inside the component,
		* with a distance of m_TextInside in mils */
		bool m_DrawPinNum;
		bool m_DrawPinName;
		LibDrawField* Fields; /* Auxiliairy Field list (id = 2 a 11) */
		LibEDA_BaseStruct* m_Drawings; /* How to draw this part */
		long m_LastDate; // Last change Date

		public:
		virtual wxString GetClass() const
		{
		return wxT( "EDA_LibComponentStruct" );
		}


		EDA_LibComponentStruct( const wxChar* CmpName );
		EDA_Rect GetBoundaryBox( int Unit, int Convert ); /* return Box around the part. */

		~EDA_LibComponentStruct();
		void SortDrawItems();
		};


		/**************************************************************************/
		/* class to handle an alias of an usual component in lib (root component) */
		/**************************************************************************/
		class EDA_LibCmpAliasStruct : public LibCmpEntry
		{
		public:
		wxString m_RootName; /* Root component Part name */

		public:
		EDA_LibCmpAliasStruct( const wxChar* CmpName, const wxChar* CmpRootName );
		~EDA_LibCmpAliasStruct();
		virtual wxString GetClass() const
		{
		return wxT( "EDA_LibCmpAliasStruct" );
		}
		};


		#endif // CLASS_LIBRARY_H

eeschema/class_pin.cpp

0 → 100644

+426 −0

Original line number	Diff line number	Diff line
		/*****************/
		/* class_pin.cpp */
		/*****************/

		#include "fctsys.h"
		#include "gr_basic.h"

		#include "common.h"
		#include "program.h"
		#include "libcmp.h"
		#include "general.h"
		#include "protos.h"


		/**********************************************************************************************/
		void LibDrawPin::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC, const wxPoint& aOffset, int aColor,
		int aDrawMode, void* aData, int aTransformMatrix[2][2] )
		/**********************************************************************************************/
		{
		if( ( m_Attributs & PINNOTDRAW ) && !g_ShowAllPins )
		return;

		EDA_LibComponentStruct* Entry = ( (DrawPinPrms*) aData )->m_Entry;
		bool DrawPinText = ( (DrawPinPrms*) aData )->m_DrawPinText;

		/* Calculate Pin orient takin in account the component orientation */
		int orient = ReturnPinDrawOrient( aTransformMatrix );

		/* Calculate the pin position */
		wxPoint pos1 = TransformCoordinate( aTransformMatrix, m_Pos ) + aOffset;

		/* Dessin de la pin et du symbole special associe */
		DrawPinSymbol( aPanel, aDC, pos1, orient, aDrawMode, aColor );

		if( DrawPinText )
		{
		DrawPinTexts( aPanel, aDC, pos1, orient,
		Entry->m_TextInside,
		Entry->m_DrawPinNum, Entry->m_DrawPinName,
		aColor, aDrawMode );
		}
		}


		/********************************************************************************/
		void LibDrawPin::DrawPinSymbol( WinEDA_DrawPanel* aPanel, wxDC* aDC,
		const wxPoint& aPinPos, int aOrient, int aDrawMode, int aColor )
		/*******************************************************************************/

		/* Draw the pin symbol (without texts)
		* if Color != 0 draw with Color, else with the normal pin color
		*/
		{
		int MapX1, MapY1, x1, y1;
		int color;
		int width = MAX( m_Width, g_DrawMinimunLineWidth );
		int posX = aPinPos.x, posY = aPinPos.y, len = m_PinLen;


		color = ReturnLayerColor( LAYER_PIN );
		if( aColor < 0 ) // Used normal color or selected color
		{
		if( (m_Selected & IS_SELECTED) )
		color = g_ItemSelectetColor;
		}
		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;
		}

		if( m_PinShape & INVERT )
		{
		GRCircle( &aPanel->m_ClipBox, aDC, MapX1 * INVERT_PIN_RADIUS + x1,
		MapY1 * INVERT_PIN_RADIUS + y1,
		INVERT_PIN_RADIUS, width, color );

		GRMoveTo( MapX1 * INVERT_PIN_RADIUS * 2 + x1,
		MapY1 * INVERT_PIN_RADIUS * 2 + y1 );
		GRLineTo( &aPanel->m_ClipBox, aDC, posX, posY, width, color );
		}
		else
		{
		GRMoveTo( x1, y1 );
		GRLineTo( &aPanel->m_ClipBox, aDC, posX, posY, width, color );
		}

		if( m_PinShape & CLOCK )
		{
		if( MapY1 == 0 ) /* MapX1 = +- 1 */
		{
		GRMoveTo( x1, y1 + CLOCK_PIN_DIM );
		GRLineTo( &aPanel->m_ClipBox, aDC, x1 - MapX1 * CLOCK_PIN_DIM, y1, width, color );
		GRLineTo( &aPanel->m_ClipBox, aDC, x1, y1 - CLOCK_PIN_DIM, width, color );
		}
		else /* MapX1 = 0 */
		{
		GRMoveTo( x1 + CLOCK_PIN_DIM, y1 );
		GRLineTo( &aPanel->m_ClipBox, aDC, x1, y1 - MapY1 * CLOCK_PIN_DIM, width, color );
		GRLineTo( &aPanel->m_ClipBox, aDC, x1 - CLOCK_PIN_DIM, y1, width, color );
		}
		}

		if( m_PinShape & LOWLEVEL_IN ) /* IEEE symbol "Active Low Input" */
		{
		if( MapY1 == 0 ) /* MapX1 = +- 1 */
		{
		GRMoveTo( x1 + MapX1 * IEEE_SYMBOL_PIN_DIM * 2, y1 );
		GRLineTo( &aPanel->m_ClipBox, aDC, x1 + MapX1 * IEEE_SYMBOL_PIN_DIM * 2,
		y1 - IEEE_SYMBOL_PIN_DIM, width, color );
		GRLineTo( &aPanel->m_ClipBox, aDC, x1, y1, width, color );
		}
		else /* MapX1 = 0 */
		{
		GRMoveTo( x1, y1 + MapY1 * IEEE_SYMBOL_PIN_DIM * 2 );
		GRLineTo( &aPanel->m_ClipBox, aDC, x1 - IEEE_SYMBOL_PIN_DIM,
		y1 + MapY1 * IEEE_SYMBOL_PIN_DIM * 2, width, color );
		GRLineTo( &aPanel->m_ClipBox, aDC, x1, y1, width, color );
		}
		}


		if( m_PinShape & LOWLEVEL_OUT ) /* IEEE symbol "Active Low Output" */
		{
		if( MapY1 == 0 ) /* MapX1 = +- 1 */
		{
		GRMoveTo( x1, y1 - IEEE_SYMBOL_PIN_DIM );
		GRLineTo( &aPanel->m_ClipBox,
		aDC,
		x1 + MapX1 * IEEE_SYMBOL_PIN_DIM * 2,
		y1,
		width,
		color );
		}
		else /* MapX1 = 0 */
		{
		GRMoveTo( x1 - IEEE_SYMBOL_PIN_DIM, y1 );
		GRLineTo( &aPanel->m_ClipBox,
		aDC,
		x1,
		y1 + MapY1 * IEEE_SYMBOL_PIN_DIM * 2,
		width,
		color );
		}
		}

		/* Draw the pin end target (active end of the pin) */
		if( !g_IsPrinting ) // Draw but do not print the pin end target 1 pixel width */
		GRCircle( &aPanel->m_ClipBox, aDC, posX, posY, TARGET_PIN_DIAM, 0, color );
		}


		/*****************************************************************************
		* Put out pin number and pin text info, given the pin line coordinates.
		* The line must be vertical or horizontal.
		* If PinText == NULL nothing is printed. If PinNum = 0 no number is printed.
		* Current Zoom factor is taken into account.
		* If TextInside then the text is been put inside,otherwise all is drawn outside.
		* Pin Name: substring beteween '~' is negated
		*****************************************************************************/
		void LibDrawPin::DrawPinTexts( WinEDA_DrawPanel* panel, wxDC* DC,
		wxPoint& pin_pos, int orient,
		int TextInside, bool DrawPinNum, bool DrawPinName,
		int Color, int DrawMode )
		/* DrawMode = GR_OR, XOR ... */
		{
		int ii, x, y, x1, y1, dx, dy, len;
		wxString StringPinNum;
		wxString PinText;
		int PinTextBarPos[256];
		int PinTextBarCount;
		int NameColor, NumColor;
		int PinTxtLen;

		wxSize PinNameSize( m_PinNameSize, m_PinNameSize );
		wxSize PinNumSize( m_PinNumSize, m_PinNumSize );

		int LineWidth = g_DrawMinimunLineWidth;

		GRSetDrawMode( DC, DrawMode );

		/* Get the num and name colors */
		if( (Color < 0) && (m_Selected & IS_SELECTED) )
		Color = g_ItemSelectetColor;
		NameColor = Color == -1 ? ReturnLayerColor( LAYER_PINNAM ) : Color;
		NumColor = Color == -1 ? ReturnLayerColor( LAYER_PINNUM ) : Color;

		/* Create the pin num string */
		ReturnPinStringNum( StringPinNum );

		x1 = pin_pos.x; y1 = pin_pos.y;

		switch( orient )
		{
		case PIN_UP:
		y1 -= m_PinLen; break;

		case PIN_DOWN:
		y1 += m_PinLen; break;

		case PIN_LEFT:
		x1 -= m_PinLen; break;

		case PIN_RIGHT:
		x1 += m_PinLen; break;
		}

		const wxChar* textsrc = m_PinName.GetData();
		float fPinTextPitch = PinNameSize.x * 1.1;
		/* Do we need to invert the string? Is this string has only "~"? */
		PinTextBarCount = 0; PinTxtLen = 0;
		ii = 0;
		while( *textsrc )
		{
		if( *textsrc == '~' )
		{
		PinTextBarPos[PinTextBarCount++] = (int) (PinTxtLen * fPinTextPitch);
		}
		else
		{
		PinText.Append( *textsrc );
		PinTxtLen++;
		}

		textsrc++;
		}

		PinTxtLen = (int) (fPinTextPitch * PinTxtLen);
		PinTextBarPos[PinTextBarCount] = PinTxtLen; // Needed if no end '~'

		if( PinText[0] == 0 )
		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( PinText && DrawPinName )
		{
		if( orient == PIN_RIGHT )
		{
		x = x1 + TextInside;
		DrawGraphicText( panel, DC, wxPoint( x, y1 ), NameColor, PinText,
		TEXT_ORIENT_HORIZ,
		PinNameSize,
		GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, LineWidth );

		for( ii = 0; ii < PinTextBarCount; )
		{
		GRMoveTo( x, y1 - TXTMARGE );
		dy = -PinNameSize.y / 2;
		GRMoveRel( 0, dy );
		dx = PinTextBarPos[ii++]; // Get the line pos
		GRMoveRel( dx, 0 );
		len = PinTextBarPos[ii++] - dx; // Get the line length
		GRLineRel( &panel->m_ClipBox, DC, len, 0, LineWidth, NameColor );
		}
		}
		else // Orient == PIN_LEFT
		{
		x = x1 - TextInside;
		DrawGraphicText( panel, DC, wxPoint( x, y1 ), NameColor, PinText,
		TEXT_ORIENT_HORIZ,
		PinNameSize,
		GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_CENTER, LineWidth );

		for( ii = 0; ii < PinTextBarCount; )
		{
		GRMoveTo( x, y1 - TXTMARGE );
		dy = -PinNameSize.y / 2;
		GRMoveRel( 0, dy );
		dx = PinTextBarPos[ii++]; // Get the line pos
		GRMoveRel( dx - PinTxtLen, 0 );
		len = PinTextBarPos[ii++] - dx; // Get the line length
		GRLineRel( &panel->m_ClipBox, DC, len, 0, LineWidth, NameColor );
		}
		}
		}

		if( DrawPinNum )
		{
		DrawGraphicText( panel, DC,
		wxPoint( (x1 + pin_pos.x) / 2, y1 - TXTMARGE ), NumColor, StringPinNum,
		TEXT_ORIENT_HORIZ, PinNumSize,
		GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM, LineWidth );
		}
		}
		else /* Its a vertical line. */
		{
		// Text is drawn from bottom to top (i.e. to negative value for Y axis)
		if( PinText && DrawPinName )
		{
		if( orient == PIN_DOWN )
		{
		y = y1 + TextInside;

		DrawGraphicText( panel, DC, wxPoint( x1, y ), NameColor, PinText,
		TEXT_ORIENT_VERT, PinNameSize,
		GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_TOP, LineWidth );

		for( ii = 0; ii < PinTextBarCount; )
		{
		GRMoveTo( x1 - TXTMARGE, y );
		dy = -PinNameSize.y / 2;
		GRMoveRel( dy, 0 );
		dx = PinTextBarPos[ii++]; // Get the line pos
		GRMoveRel( 0, PinTxtLen - dx );
		len = PinTextBarPos[ii++] - dx; // Get the line length
		GRLineRel( &panel->m_ClipBox, DC, 0, -len, LineWidth, NameColor );
		}
		}
		else /* PIN_UP */
		{
		y = y1 - TextInside;

		DrawGraphicText( panel, DC, wxPoint( x1, y ), NameColor, PinText,
		TEXT_ORIENT_VERT, PinNameSize,
		GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM, LineWidth );

		for( ii = 0; ii < PinTextBarCount; )
		{
		GRMoveTo( x1 - TXTMARGE, y );
		dy = -PinNameSize.y / 2;
		GRMoveRel( dy, 0 );
		dx = PinTextBarPos[ii++]; // Get the line pos
		GRMoveRel( 0, -dx );
		len = PinTextBarPos[ii++] - dx; // Get the line length
		GRLineRel( &panel->m_ClipBox, DC, 0, -len, LineWidth, NameColor );
		}
		}
		}

		if( DrawPinNum )
		{
		DrawGraphicText( panel, DC,
		wxPoint( x1 - TXTMARGE, (y1 + pin_pos.y) / 2 ), NumColor, StringPinNum,
		TEXT_ORIENT_VERT, PinNumSize,
		GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_CENTER, LineWidth );
		}
		}
		}
		else /** Draw num & text pin outside **/
		{
		if( (orient == PIN_LEFT) \|\| (orient == PIN_RIGHT) )
		/* Its an horizontal line. */
		{
		if( PinText && DrawPinName )
		{
		x = (x1 + pin_pos.x) / 2;
		DrawGraphicText( panel, DC, wxPoint( x, y1 - TXTMARGE ),
		NameColor, PinText,
		TEXT_ORIENT_HORIZ, PinNameSize,
		GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM, LineWidth );

		for( ii = 0; ii < PinTextBarCount; )
		{
		GRMoveTo( x, y1 - TXTMARGE * 2 );
		GRMoveRel( -PinTxtLen / 2, -PinNameSize.y );
		dx = PinTextBarPos[ii++]; // Get the line pos
		GRMoveRel( dx, 0 );
		len = PinTextBarPos[ii++] - dx; // Get the line length
		GRLineRel( &panel->m_ClipBox, DC, len, 0, LineWidth, NameColor );
		}
		}
		if( DrawPinNum )
		{
		x = (x1 + pin_pos.x) / 2;
		DrawGraphicText( panel, DC, wxPoint( x, y1 + TXTMARGE ),
		NumColor, StringPinNum,
		TEXT_ORIENT_HORIZ, PinNumSize,
		GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_TOP, LineWidth );
		}
		}
		else /* Its a vertical line. */
		{
		if( PinText && DrawPinName )
		{
		y = (y1 + pin_pos.y) / 2;
		DrawGraphicText( panel, DC, wxPoint( x1 - TXTMARGE, y ),
		NameColor, PinText,
		TEXT_ORIENT_VERT, PinNameSize,
		GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_CENTER, LineWidth );

		for( ii = 0; ii < PinTextBarCount; )
		{
		GRMoveTo( x1 - (TXTMARGE * 2), y );
		GRMoveRel( -PinNameSize.y, -PinTxtLen / 2 );
		dx = PinTextBarPos[ii++]; // Get the line pos
		GRMoveRel( 0, PinTxtLen - dx );
		len = PinTextBarPos[ii++] - dx; // Get the line length
		GRLineRel( &panel->m_ClipBox, DC, 0, -len, LineWidth, NameColor );
		}
		}

		if( DrawPinNum )
		{
		DrawGraphicText( panel, DC, wxPoint( x1 + TXTMARGE, (y1 + pin_pos.y) / 2 ),
		NumColor, StringPinNum,
		TEXT_ORIENT_VERT, PinNumSize,
		GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, LineWidth );
		}
		}
		}
		}

Admin message