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

Component library object improvements. 

* Library component objects can now draw themselves without external drawing code.
* Fix all the library drawing and field objects to support component drawing code.
* Provide proper file dialog wild card for symbol libraries and us wxFileDialog.
* Update component library editing code to reflect component drawing changes.
This commit is contained in:
stambaughw 2009-09-04 18:57:37 +00:00
parent d4a5e5acb7
commit 7c7d675cbf
26 changed files with 998 additions and 1211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

215
eeschema/block_libedit.cpp
View File

@ -1,5 +1,5 @@
/****************************************************/
/* block_libedt.cpp */
/* block_libedit.cpp */
/* Gestion des Operations sur Blocks et Effacements */
/****************************************************/
@ -15,24 +15,21 @@
#include "general.h"
#include "protos.h"
/* Variables Locales */
/* Fonctions exportees */
/* Fonctions Locales */
static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC, bool erase );
static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC,
bool erase );
static int MarkItemsInBloc( EDA_LibComponentStruct* LibComponent,
EDA_Rect& Rect );
EDA_Rect& Rect );
static void ClearMarkItems( EDA_LibComponentStruct* LibComponent );
static void CopyMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset );
static void MoveMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset );
static void MirrorMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset );
static void MirrorMarkedItems( EDA_LibComponentStruct* LibEntry,
wxPoint offset );
static void DeleteMarkedItems( EDA_LibComponentStruct* LibEntry );
/*********************************************************/
void ClearMarkItems( EDA_LibComponentStruct* LibComponent )
/*********************************************************/
{
LibEDA_BaseStruct* item;
@ -45,27 +42,27 @@ void ClearMarkItems( EDA_LibComponentStruct* LibComponent )
}
/***************************************************************/
/*
* Mark items inside rect.
* Items are inside rect when an end point is inside rect
*
* Rules for convert drawings and other parts ( for multi part per package):
* - Commons are always marked
* - Specific graphic shapes must agree with the current displayed part and
* convert
* - Because most of pins are specific to current part and current convert:
* - if g_EditPinByPinIsOn == TRUE, or flag .m_UnitSelectionLocked == TRUE,
* only the pins specific to current part and current convert are marked
* - all specific to current convert pins are marked;
*/
int MarkItemsInBloc( EDA_LibComponentStruct* LibComponent,
EDA_Rect& Rect )
/***************************************************************/
/* Mark items inside rect.
* Items are inside rect when an end point is inside rect
*
* Rules for convert drawings and other parts ( for multi part per package):
* - Commons are always marked
* - Specific graphic shapes must agree with the current displayed part and convert
* - Because most of pins are specific to current part and current convert:
* - if g_EditPinByPinIsOn == TRUE, or flag .m_UnitSelectionLocked == TRUE,
* only the pins specific to current part and current convert are marked
* - all specific to current convert pins are marked;
*/
{
LibEDA_BaseStruct* item;
int ItemsCount = 0;
int ItemsCount = 0;
wxPoint pos;
bool ItemIsInOtherPart, ItemIsInOtherConvert;
bool ItemIsInOtherPart;
bool ItemIsInOtherConvert;
if( LibComponent == NULL )
return 0;
@ -188,7 +185,7 @@ int MarkItemsInBloc( EDA_LibComponentStruct* LibComponent,
case COMPONENT_FIELD_DRAW_TYPE:
break;
default:
defualt:
break;
}
}
@ -197,13 +194,11 @@ int MarkItemsInBloc( EDA_LibComponentStruct* LibComponent,
}
/*************************************************************************/
int WinEDA_LibeditFrame::ReturnBlockCommand( int key )
/*************************************************************************/
/* Return the block command (BLOCK_MOVE, BLOCK_COPY...) corresponding to
/*
* Return the block command (BLOCK_MOVE, BLOCK_COPY...) corresponding to
* the key (ALT, SHIFT ALT ..)
*/
int WinEDA_LibeditFrame::ReturnBlockCommand( int key )
{
int cmd;
@ -243,17 +238,17 @@ int WinEDA_LibeditFrame::ReturnBlockCommand( int key )
}
/****************************************************/
int WinEDA_LibeditFrame::HandleBlockEnd( wxDC* DC )
/****************************************************/
/* Command BLOCK END (end of block sizing)
/*
* Command BLOCK END (end of block sizing)
* return :
* 0 if command finished (zoom, delete ...)
* 1 if HandleBlockPlace must follow (items found, and a block place command must follow)
* 1 if HandleBlockPlace must follow (items found, and a block place
* command must follow)
*/
int WinEDA_LibeditFrame::HandleBlockEnd( wxDC* DC )
{
int ItemsCount = 0, MustDoPlace = 0;
int ItemsCount = 0;
int MustDoPlace = 0;
if( GetScreen()->m_BlockLocate.GetCount() )
{
@ -278,7 +273,8 @@ int WinEDA_LibeditFrame::HandleBlockEnd( wxDC* DC )
case BLOCK_DRAG: /* Drag */
case BLOCK_MOVE: /* Move */
case BLOCK_COPY: /* Copy */
ItemsCount = MarkItemsInBloc( CurrentLibEntry, GetScreen()->m_BlockLocate );
ItemsCount = MarkItemsInBloc( CurrentLibEntry,
GetScreen()->m_BlockLocate );
if( ItemsCount )
{
MustDoPlace = 1;
@ -300,7 +296,8 @@ int WinEDA_LibeditFrame::HandleBlockEnd( wxDC* DC )
break;
case BLOCK_DELETE: /* Delete */
ItemsCount = MarkItemsInBloc( CurrentLibEntry, GetScreen()->m_BlockLocate );
ItemsCount = MarkItemsInBloc( CurrentLibEntry,
GetScreen()->m_BlockLocate );
if( ItemsCount )
SaveCopyInUndoList( CurrentLibEntry );
DeleteMarkedItems( CurrentLibEntry );
@ -315,10 +312,12 @@ int WinEDA_LibeditFrame::HandleBlockEnd( wxDC* DC )
case BLOCK_MIRROR_Y:
ItemsCount = MarkItemsInBloc( CurrentLibEntry, GetScreen()->m_BlockLocate );
ItemsCount = MarkItemsInBloc( CurrentLibEntry,
GetScreen()->m_BlockLocate );
if( ItemsCount )
SaveCopyInUndoList( CurrentLibEntry );
MirrorMarkedItems( CurrentLibEntry, GetScreen()->m_BlockLocate.Centre() );
MirrorMarkedItems( CurrentLibEntry,
GetScreen()->m_BlockLocate.Centre() );
break;
case BLOCK_ZOOM: /* Window Zoom */
@ -344,7 +343,8 @@ int WinEDA_LibeditFrame::HandleBlockEnd( wxDC* DC )
DrawPanel->ManageCurseur = NULL;
DrawPanel->ForceCloseManageCurseur = NULL;
GetScreen()->SetCurItem( NULL );
SetToolID( m_ID_current_state, DrawPanel->m_PanelDefaultCursor, wxEmptyString );
SetToolID( m_ID_current_state, DrawPanel->m_PanelDefaultCursor,
wxEmptyString );
DrawPanel->Refresh( TRUE );
}
@ -353,15 +353,13 @@ int WinEDA_LibeditFrame::HandleBlockEnd( wxDC* DC )
}
/******************************************************/
void WinEDA_LibeditFrame::HandleBlockPlace( wxDC* DC )
/******************************************************/
/* Routine to handle the BLOCK PLACE commande
/*
* Routine to handle the BLOCK PLACE commande
* Last routine for block operation for:
* - block move & drag
* - block copie & paste
*/
void WinEDA_LibeditFrame::HandleBlockPlace( wxDC* DC )
{
bool err = FALSE;
@ -384,14 +382,16 @@ void WinEDA_LibeditFrame::HandleBlockPlace( wxDC* DC )
case BLOCK_PRESELECT_MOVE: /* Move with preselection list*/
GetScreen()->m_BlockLocate.ClearItemsList();
SaveCopyInUndoList( CurrentLibEntry );
MoveMarkedItems( CurrentLibEntry, GetScreen()->m_BlockLocate.m_MoveVector );
MoveMarkedItems( CurrentLibEntry,
GetScreen()->m_BlockLocate.m_MoveVector );
DrawPanel->Refresh( TRUE );
break;
case BLOCK_COPY: /* Copy */
GetScreen()->m_BlockLocate.ClearItemsList();
SaveCopyInUndoList( CurrentLibEntry );
CopyMarkedItems( CurrentLibEntry, GetScreen()->m_BlockLocate.m_MoveVector );
CopyMarkedItems( CurrentLibEntry,
GetScreen()->m_BlockLocate.m_MoveVector );
break;
case BLOCK_PASTE: /* Paste (recopie du dernier bloc sauve */
@ -400,7 +400,8 @@ void WinEDA_LibeditFrame::HandleBlockPlace( wxDC* DC )
case BLOCK_MIRROR_Y: /* Invert by popup menu, from block move */
SaveCopyInUndoList( CurrentLibEntry );
MirrorMarkedItems( CurrentLibEntry, GetScreen()->m_BlockLocate.Centre() );
MirrorMarkedItems( CurrentLibEntry,
GetScreen()->m_BlockLocate.Centre() );
break;
case BLOCK_ZOOM: // Handled by HandleBlockEnd
@ -414,31 +415,28 @@ void WinEDA_LibeditFrame::HandleBlockPlace( wxDC* DC )
GetScreen()->SetModify();
DrawPanel->ManageCurseur = NULL;
DrawPanel->ForceCloseManageCurseur = NULL;
DrawPanel->ManageCurseur = NULL;
DrawPanel->ForceCloseManageCurseur = NULL;
GetScreen()->m_BlockLocate.m_Flags = 0;
GetScreen()->m_BlockLocate.m_State = STATE_NO_BLOCK;
GetScreen()->m_BlockLocate.m_Command = BLOCK_IDLE;
GetScreen()->SetCurItem( NULL );
DrawPanel->Refresh( TRUE );
SetToolID( m_ID_current_state, DrawPanel->m_PanelDefaultCursor, wxEmptyString );
SetToolID( m_ID_current_state, DrawPanel->m_PanelDefaultCursor,
wxEmptyString );
}
/************************************************************************/
static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC,
bool erase )
/************************************************************************/
/* Retrace le contour du block de recherche de structures
/*
* Retrace le contour du block de recherche de structures
* L'ensemble du block suit le curseur
*/
static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC,
bool erase )
{
BLOCK_SELECTOR* PtBlock;
BASE_SCREEN* screen = panel->GetScreen();
LibEDA_BaseStruct* item;
wxPoint move_offset;
PtBlock = &screen->m_BlockLocate;
@ -446,60 +444,42 @@ static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC,
/* Effacement ancien cadre */
if( erase )
{
PtBlock->Draw( panel, DC, PtBlock->m_MoveVector, g_XorMode, PtBlock->m_Color );
PtBlock->Draw( panel, DC, PtBlock->m_MoveVector, g_XorMode,
PtBlock->m_Color );
if( CurrentLibEntry )
{
item = CurrentLibEntry->m_Drawings;
for( ; item != NULL; item = item->Next() )
{
if( item->m_Selected == 0 )
continue;
/* Do not draw items for other units */
if( CurrentUnit && item->m_Unit && (item->m_Unit != CurrentUnit) )
continue;
if( CurrentConvert && item->m_Convert && (item->m_Convert != CurrentConvert) )
continue;
DrawLibraryDrawStruct( panel, DC, CurrentLibEntry,
PtBlock->m_MoveVector, item, g_XorMode );
}
CurrentLibEntry->Draw( panel, DC, PtBlock->m_MoveVector,
CurrentUnit, CurrentConvert, g_XorMode,
-1, DefaultTransformMatrix, true, false,
true );
}
}
/* Redessin nouvel affichage */
PtBlock->m_MoveVector.x = screen->m_Curseur.x - PtBlock->m_BlockLastCursorPosition.x;
PtBlock->m_MoveVector.y = screen->m_Curseur.y - PtBlock->m_BlockLastCursorPosition.y;
PtBlock->m_MoveVector.x =
screen->m_Curseur.x - PtBlock->m_BlockLastCursorPosition.x;
PtBlock->m_MoveVector.y =
screen->m_Curseur.y - PtBlock->m_BlockLastCursorPosition.y;
GRSetDrawMode( DC, g_XorMode );
PtBlock->Draw( panel, DC, PtBlock->m_MoveVector, g_XorMode, PtBlock->m_Color );
PtBlock->Draw( panel, DC, PtBlock->m_MoveVector, g_XorMode,
PtBlock->m_Color );
if( CurrentLibEntry )
{
item = CurrentLibEntry->m_Drawings;
for( ; item != NULL; item = item->Next() )
{
if( item->m_Selected == 0 )
continue;
/* Do not draw items for other units */
if( CurrentUnit && item->m_Unit && (item->m_Unit != CurrentUnit) )
continue;
if( CurrentConvert && item->m_Convert && (item->m_Convert != CurrentConvert) )
continue;
DrawLibraryDrawStruct( panel, DC, CurrentLibEntry,
PtBlock->m_MoveVector,
item, g_XorMode );
}
CurrentLibEntry->Draw( panel, DC, PtBlock->m_MoveVector,
CurrentUnit, CurrentConvert, g_XorMode,
-1, DefaultTransformMatrix, true, false,
true );
}
}
/****************************************************************************/
void CopyMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset )
/****************************************************************************/
/* Copy marked items, at new position = old position + offset
/*
* Copy marked items, at new position = old position + offset
*/
void CopyMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset )
{
LibEDA_BaseStruct* item;
@ -522,12 +502,10 @@ void CopyMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset )
}
/****************************************************************************/
void MoveMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset )
/****************************************************************************/
/* Move marked items, at new position = old position + offset
/*
* Move marked items, at new position = old position + offset
*/
void MoveMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset )
{
LibEDA_BaseStruct* item;
@ -549,7 +527,7 @@ void MoveMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset )
case COMPONENT_ARC_DRAW_TYPE:
{
( (LibDrawArc*) item )->m_Pos += offset;
( (LibDrawArc*) item )->m_Pos += offset;
( (LibDrawArc*) item )->m_ArcStart += offset;
( (LibDrawArc*) item )->m_ArcEnd += offset;
break;
@ -580,7 +558,7 @@ void MoveMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset )
break;
default:
;
break;
}
item->m_Flags = item->m_Selected = 0;
@ -588,12 +566,10 @@ void MoveMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset )
}
/******************************************************/
void DeleteMarkedItems( EDA_LibComponentStruct* LibEntry )
/******************************************************/
/* Delete marked items
/*
* Delete marked items
*/
void DeleteMarkedItems( EDA_LibComponentStruct* LibEntry )
{
LibEDA_BaseStruct* item, * next_item;
@ -606,17 +582,15 @@ void DeleteMarkedItems( EDA_LibComponentStruct* LibEntry )
next_item = item->Next();
if( item->m_Selected == 0 )
continue;
DeleteOneLibraryDrawStruct( NULL, NULL, LibEntry, item, 0 );
LibEntry->RemoveDrawItem( item );
}
}
/****************************************************************************/
void MirrorMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset )
/****************************************************************************/
/* Mirror marked items, refer to a Vertical axis at position offset
/*
* Mirror marked items, refer to a Vertical axis at position offset
*/
void MirrorMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset )
{
#define SETMIRROR( z ) (z) -= offset.x; (z) = -(z); (z) += offset.x;
LibEDA_BaseStruct* item;
@ -658,7 +632,8 @@ void MirrorMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset )
SETMIRROR( ( (LibDrawArc*) item )->m_Pos.x );
SETMIRROR( ( (LibDrawArc*) item )->m_ArcStart.x );
SETMIRROR( ( (LibDrawArc*) item )->m_ArcEnd.x );
EXCHG( ( (LibDrawArc*) item )->m_ArcStart, ( (LibDrawArc*) item )->m_ArcEnd );
EXCHG( ( (LibDrawArc*) item )->m_ArcStart,
( (LibDrawArc*) item )->m_ArcEnd );
break;
}
@ -689,7 +664,7 @@ void MirrorMarkedItems( EDA_LibComponentStruct* LibEntry, wxPoint offset )
break;
default:
;
break;
}
item->m_Flags = item->m_Selected = 0;

11
eeschema/class_BodyItem_Text.cpp
View File

@ -42,7 +42,8 @@ bool LibDrawText::Save( FILE* ExportFile ) const
fprintf( ExportFile, "T %d %d %d %d %d %d %d %s ", m_Orient,
m_Pos.x, m_Pos.y, m_Size.x, m_Attributs, m_Unit, m_Convert,
CONV_TO_UTF8( text ) );
fprintf( ExportFile, " %s %d", m_Italic ? "Italic" : "Normal", (m_Bold>0) ? 1 : 0 );
fprintf( ExportFile, " %s %d", m_Italic ? "Italic" : "Normal",
( m_Bold>0 ) ? 1 : 0 );
char hjustify = 'C';
if( m_HJustify == GR_TEXT_HJUSTIFY_LEFT )
@ -76,7 +77,8 @@ bool LibDrawText::Load( char* line, wxString& errorMsg )
cnt = sscanf( &line[2], "%d %d %d %d %d %d %d %s %s %d %c %c",
&m_Orient, &m_Pos.x, &m_Pos.y, &m_Size.x, &m_Attributs,
&m_Unit, &m_Convert, buf, tmp, &thickness, &hjustify, &vjustify );
&m_Unit, &m_Convert, buf, tmp, &thickness, &hjustify,
&vjustify );
if( cnt < 8 )
{
@ -149,7 +151,8 @@ bool LibDrawText::HitTest( const wxPoint& refPos )
* @param aThreshold = unused here (TextHitTest calculates its threshold )
* @param aTransMat = the transform matrix
*/
bool LibDrawText::HitTest( wxPoint aPosRef, int aThreshold, const int aTransMat[2][2] )
bool LibDrawText::HitTest( wxPoint aPosRef, int aThreshold,
const int aTransMat[2][2] )
{
wxPoint physicalpos = TransformCoordinate( aTransMat, m_Pos );
wxPoint tmp = m_Pos;
@ -229,6 +232,8 @@ void LibDrawText::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
* transformation matrix causes xy axes to be flipped. */
int t1 = ( aTransformMatrix[0][0] != 0 ) ^ ( m_Orient != 0 );
GRSetDrawMode( aDC, aDrawMode );
DrawGraphicText( aPanel, aDC, pos1, (EDA_Colors) color, m_Text,
t1 ? TEXT_ORIENT_HORIZ : TEXT_ORIENT_VERT,
m_Size, m_HJustify, m_VJustify,

135
eeschema/class_libentry.cpp
View File

@ -6,15 +6,14 @@
#include "common.h"
#include "kicad_string.h"
#include "confirm.h"
#include "class_drawpanel.h"
#include "gr_basic.h"
#include "program.h"
#include "libcmp.h"
#include "general.h"
#include "protos.h"
#include <wx/tokenzr.h>
#include <wx/txtstrm.h>
int SortItemsFct(const void* ref, const void* item)
{
@ -260,6 +259,136 @@ EDA_LibComponentStruct::~EDA_LibComponentStruct()
}
void EDA_LibComponentStruct::Draw( WinEDA_DrawPanel* panel, wxDC* dc,
const wxPoint& offset, int multi,
int convert, int drawMode, int color,
const int transformMatrix[2][2],
bool showPinText, bool drawFields,
bool onlySelected )
{
wxString fieldText;
LibDrawField* Field;
LibEDA_BaseStruct* drawItem;
BASE_SCREEN* screen = panel->GetScreen();
GRSetDrawMode( dc, drawMode );
for( drawItem = m_Drawings; drawItem != NULL; drawItem = drawItem->Next() )
{
if( onlySelected && drawItem->m_Selected == 0 )
continue;
// Do not draw an item while moving (the cursor handler does that)
if( drawItem->m_Flags & IS_MOVED )
continue;
/* Do not draw items not attached to the current part */
if( multi && drawItem->m_Unit && ( drawItem->m_Unit != multi ) )
continue;
if( convert && drawItem->m_Convert && ( drawItem->m_Convert != convert ) )
continue;
if( drawItem->Type() == COMPONENT_PIN_DRAW_TYPE )
{
drawItem->Draw( panel, dc, offset, color, drawMode, &showPinText,
transformMatrix );
}
else
{
bool force_nofill =
( screen->m_IsPrinting
&& drawItem->m_Fill == FILLED_WITH_BG_BODYCOLOR
&& GetGRForceBlackPenState() );
drawItem->Draw( panel, dc, offset, color, drawMode,
(void*) force_nofill, transformMatrix );
}
}
if( drawFields )
{
/* The reference designator field is a special case for naming
* convention.
*
* FIXME: This should be handled by the LibDrawField class.
*/
if( m_UnitCount > 1 )
{
#if defined(KICAD_GOST)
fieldText.Printf( wxT( "%s?.%c" ), (const wxChar*) m_Prefix.m_Text,
multi + '1' - 1 );
#else
fieldText.Printf( wxT( "%s?%c" ), (const wxChar*) m_Prefix.m_Text,
multi + 'A' - 1 );
#endif
}
else
{
fieldText = m_Prefix.m_Text + wxT( "?" );
}
m_Prefix.Draw( panel, dc, offset, color, drawMode, &fieldText,
transformMatrix );
m_Name.Draw( panel, dc, offset, color, drawMode, NULL, transformMatrix );
for( Field = m_Fields; Field != NULL; Field = Field->Next() )
{
Field->Draw( panel, dc, offset, color, drawMode, NULL,
transformMatrix );
}
}
int len = panel->GetScreen()->Unscale( 3 );
GRLine( &panel->m_ClipBox, dc, offset.x, offset.y - len, offset.x,
offset.y + len, 0, color );
GRLine( &panel->m_ClipBox, dc, offset.x - len, offset.y, offset.x + len,
offset.y, 0, color );
/* Enable this to draw the bounding box around the component to validate
* the bounding box calculations. */
#if 0
EDA_Rect bBox = LibEntry->GetBoundaryBox( Multi, convert );
GRRect( &panel->m_ClipBox, dc, bBox.GetOrigin().x, bBox.GetOrigin().y,
bBox.GetEnd().x, bBox.GetEnd().y, 0, LIGHTMAGENTA );
#endif
}
void EDA_LibComponentStruct::RemoveDrawItem( LibEDA_BaseStruct* item,
WinEDA_DrawPanel* panel,
wxDC* dc )
{
wxASSERT( item != NULL );
LibEDA_BaseStruct* prevItem = m_Drawings;
if( dc != NULL )
item->Draw( panel, dc, wxPoint( 0, 0 ), -1, g_XorMode, NULL,
DefaultTransformMatrix );
if( m_Drawings == item )
{
m_Drawings = item->Next();
SAFE_DELETE( item );
return;
}
while( prevItem )
{
if( prevItem->Next() == item )
{
prevItem->SetNext( item->Next() );
SAFE_DELETE( item );
break;
}
prevItem = prevItem->Next();
}
}
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.brd" format.

34
eeschema/class_libentry.h
View File

@ -165,6 +165,40 @@ public:
* @param aFields - a std::vector <LibDrawField> to import.
*/
void SetFields( const std::vector <LibDrawField> aFields );
/**
* Draw component.
*
* @param panel - Window to draw on.
* @param dc - Device context to draw on.
* @param offset - Position to component.
* @param multi - Component unit if multiple parts per component.
* @param convert - Component conversion (DeMorgan) if available.
* @param drawMode - Device context drawing mode, see wxDC.
* @param color - Color to draw component.
* @param transformMatrix - Cooridinate adjustment settings.
* @param showPinText - Show pin text if true.
* @param drawFields - Draw field text if true otherwise just draw
* body items.
* @param onlySelected - Draws only the body items that are selected.
* Used for block move redraws.
*/
void Draw( WinEDA_DrawPanel* panel, wxDC* dc, const wxPoint& offset,
int multi, int convert, int drawMode, int color = -1,
const int transformMatrix[2][2] = DefaultTransformMatrix,
bool showPinText = true, bool drawFields = true,
bool onlySelected = false );
/**
* Remove draw item from list.
*
* @param item - Draw item to remove from list.
* @param panel - Panel to remove part from.
* @param dc - Device context to remove part from.
*/
void RemoveDrawItem( LibEDA_BaseStruct* item,
WinEDA_DrawPanel* panel = NULL,
wxDC* dc = NULL );
};

32
eeschema/class_libentry_fields.cpp
View File

@ -234,10 +234,9 @@ parameter <%c> is not valid" ),
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
*/
int LibDrawField::GetPenSize( )
int LibDrawField::GetPenSize()
{
int pensize = (m_Width == 0) ? g_DrawDefaultLineThickness : m_Width;
return pensize;
return ( m_Width == 0 ) ? g_DrawDefaultLineThickness : m_Width;
}
@ -249,20 +248,24 @@ void LibDrawField::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
const wxPoint& aOffset, int aColor, int aDrawMode,
void* aData, const int aTransformMatrix[2][2] )
{
wxPoint text_pos;
wxPoint text_pos;
int color;
int linewidth = GetPenSize();
int color = aColor;
int linewidth = GetPenSize( );
linewidth = Clamp_Text_PenSize( linewidth, m_Size, m_Bold );
if( aColor < 0 ) // Used normal color or selected color
if( ( m_Attributs & TEXT_NO_VISIBLE ) && ( aColor < 0 ) )
{
if( (m_Selected & IS_SELECTED) )
color = g_ItemSelectetColor;
color = g_InvisibleItemColor;
}
else if( ( m_Selected & IS_SELECTED ) && ( aColor < 0 ) )
{
color = g_ItemSelectetColor;
}
else
{
color = aColor;
}
if( color < 0 )
{
@ -281,13 +284,14 @@ void LibDrawField::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
break;
}
}
text_pos = TransformCoordinate( aTransformMatrix, m_Pos ) + aOffset;
wxString* text = aData ? (wxString*) aData : &m_Text;
text_pos = TransformCoordinate( aTransformMatrix, m_Pos ) + aOffset;
wxString* text = aData ? (wxString*)aData : &m_Text;
GRSetDrawMode( aDC, aDrawMode );
DrawGraphicText( aPanel, aDC, text_pos, (EDA_Colors) color, text->GetData(),
DrawGraphicText( aPanel, aDC, text_pos, (EDA_Colors) color, *text,
m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
m_Size, m_HJustify, m_VJustify, linewidth, m_Italic, m_Bold );
m_Size, m_HJustify, m_VJustify, linewidth, m_Italic,
m_Bold );
}

4
eeschema/class_library.cpp
View File

@ -189,8 +189,8 @@ void LibraryStruct::RemoveEntry( LibCmpEntry* entry )
/* Remove alias name from the root component alias list */
if( Root == NULL )
{
wxLogWarning( wxT( "No root component found for alias <%s> in " \
"library <%s>." ),
wxLogWarning( wxT( "No root component found for alias <%s> in \
library <%s>." ),
( const wxChar* ) entry->m_Name.m_Text,
( const wxChar* ) m_Name );
}

25
eeschema/class_pin.cpp
View File

@ -38,7 +38,7 @@ LibDrawPin::LibDrawPin(EDA_LibComponentStruct * aParent) :
m_PinShape = NONE; /* Bit a bit: Pin shape (voir enum prec) */
m_PinType = PIN_UNSPECIFIED; /* electrical type of pin */
m_Attributs = 0; /* bit 0 != 0: pin invisible */
m_PinNum = 0; /*pin number ( i.e. 4 codes Ascii ) */
m_PinNum = 0; /*pin number ( i.e. 4 codes ASCII ) */
m_PinNumSize = 50;
m_PinNameSize = 50; /* Default size for pin name and num */
m_Width = 0;
@ -236,7 +236,7 @@ bool LibDrawPin::Load( char* line, wxString& errorMsg )
return false;
}
if( i == 12 ) /* Special Symbole defined */
if( i == 12 ) /* Special Symbol defined */
{
for( j = strlen( pinAttrs ); j > 0; )
{
@ -280,10 +280,9 @@ bool LibDrawPin::Load( char* line, wxString& errorMsg )
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
*/
int LibDrawPin::GetPenSize( )
int LibDrawPin::GetPenSize()
{
int pensize = (m_Width == 0) ? g_DrawDefaultLineThickness : m_Width;
return pensize;
return ( m_Width == 0 ) ? g_DrawDefaultLineThickness : m_Width;
}
@ -308,11 +307,14 @@ void LibDrawPin::Draw( WinEDA_DrawPanel* aPanel,
return;
}
EDA_LibComponentStruct* Entry = ( (DrawPinPrms*) aData )->m_Entry;
bool DrawPinText = ( (DrawPinPrms*) aData )->m_DrawPinText;
EDA_LibComponentStruct* Entry = GetParent();
bool DrawPinText = true;
if( ( aData != NULL ) && ( (bool*) aData == false ) )
DrawPinText = false;
/* Calculate pin orient taking in account the component orientation. */
int orient = ReturnPinDrawOrient( aTransformMatrix );
int orient = ReturnPinDrawOrient( aTransformMatrix );
/* Calculate the pin position */
wxPoint pos1 = TransformCoordinate( aTransformMatrix, m_Pos ) + aOffset;
@ -322,8 +324,7 @@ void LibDrawPin::Draw( WinEDA_DrawPanel* aPanel,
if( DrawPinText )
{
DrawPinTexts( aPanel, aDC, pos1, orient,
Entry->m_TextInside,
DrawPinTexts( aPanel, aDC, pos1, orient, Entry->m_TextInside,
Entry->m_DrawPinNum, Entry->m_DrawPinName,
aColor, aDrawMode );
}
@ -943,7 +944,7 @@ int LibDrawPin::ReturnPinDrawOrient( const int TransMat[2][2] )
end.x = 1; break;
}
end = TransformCoordinate( TransMat, end ); // = pos of end point, accordint to the component orientation
end = TransformCoordinate( TransMat, end ); // = pos of end point, according to the component orientation
orient = PIN_UP;
if( end.x == 0 )
{
@ -1044,7 +1045,7 @@ LibEDA_BaseStruct* LibDrawPin::DoGenCopy()
/** Function LibDrawPin::DisplayInfo
* Displays info (pin num and name, otientation ...
* Displays info (pin num and name, orientation ...
* on the Info window
*/
void LibDrawPin::DisplayInfo( WinEDA_DrawFrame* frame )

50
eeschema/class_sch_component.cpp
View File

@ -64,54 +64,8 @@ void DrawLibPartAux( WinEDA_DrawPanel* panel, wxDC* DC,
int Multi, int convert, int DrawMode,
int Color, bool DrawPinText )
{
wxPoint pos1, pos2;
bool force_nofill;
LibEDA_BaseStruct* DEntry;
BASE_SCREEN* screen = panel->GetScreen();
if( Entry->m_Drawings == NULL )
return;
GRSetDrawMode( DC, DrawMode );
for( DEntry = Entry->m_Drawings; DEntry != NULL; DEntry = DEntry->Next() )
{
/* Do not draw items not attached to the current part */
if( Multi && DEntry->m_Unit && (DEntry->m_Unit != Multi) )
continue;
if( convert && DEntry->m_Convert && (DEntry->m_Convert != convert) )
continue;
// Do not draw an item while moving (the cursor handler does that)
if( DEntry->m_Flags & IS_MOVED )
continue;
force_nofill = false;
switch( DEntry->Type() )
{
case COMPONENT_PIN_DRAW_TYPE:
{
DrawPinPrms prms( Entry, DrawPinText );
DEntry->Draw( panel, DC, Pos, Color, DrawMode, &prms, TransMat );
}
break;
case COMPONENT_ARC_DRAW_TYPE:
case COMPONENT_CIRCLE_DRAW_TYPE:
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
case COMPONENT_RECT_DRAW_TYPE:
case COMPONENT_POLYLINE_DRAW_TYPE:
default:
if( screen->m_IsPrinting
&& DEntry->m_Fill == FILLED_WITH_BG_BODYCOLOR
&& GetGRForceBlackPenState() )
force_nofill = true;
DEntry->Draw( panel, DC, Pos, Color, DrawMode, (void*) force_nofill,
TransMat );
break;
}
}
Entry->Draw( panel, DC, Pos, Multi, convert, DrawMode, Color, TransMat,
DrawPinText, false );
if( g_DebugLevel > 4 ) /* Draw the component boundary box */
{

203
eeschema/classes_body_items.cpp
View File

@ -18,19 +18,19 @@
static int fill_tab[3] = { 'N', 'F', 'f' };
//#define DRAW_ARC_WITH_ANGLE // Used to draw arcs
//#define DRAW_ARC_WITH_ANGLE // Used to draw arcs
/* Base class (abstract) for components bodies items */
LibEDA_BaseStruct::LibEDA_BaseStruct( KICAD_T struct_type, EDA_LibComponentStruct* aParent ) :
LibEDA_BaseStruct::LibEDA_BaseStruct( KICAD_T struct_type,
EDA_LibComponentStruct* aParent ) :
EDA_BaseStruct( struct_type )
{
m_Unit = 0; /* Unit identification (for multi part per package)
m_Unit = 0; /* Unit identification (for multi part per package)
* 0 if the item is common to all units */
m_Convert = 0; /* Shape identification (for parts which have a convert
m_Convert = 0; /* Shape identification (for parts which have a convert
* shape) 0 if the item is common to all shapes */
m_Fill = NO_FILL;
m_Fill = NO_FILL;
m_Parent = aParent;
m_typeName = _( "Undefined" );
}
@ -183,10 +183,12 @@ bool LibDrawArc::HitTest( const wxPoint& aRefPoint )
/** Function HitTest
* @return true if the point aPosRef is near this object
* @param aRefPoint = a wxPoint to test
* @param aThreshold = max distance to this object (usually the half thickness of a line)
* @param aThreshold = max distance to this object (usually the half thickness
* of a line)
* @param aTransMat = the transform matrix
*/
bool LibDrawArc::HitTest( wxPoint aRefPoint, int aThreshold, const int aTransMat[2][2] )
bool LibDrawArc::HitTest( wxPoint aRefPoint, int aThreshold,
const int aTransMat[2][2] )
{
// TODO: use aTransMat to calculmates parameters
wxPoint relpos = aRefPoint;
@ -200,10 +202,12 @@ bool LibDrawArc::HitTest( wxPoint aRefPoint, int aThreshold, const int aTransMat
if( abs( dist - m_Rayon ) > aThreshold )
return false;
// We are on the circle, ensure we are only on the arc, i.e. between m_ArcStart and m_ArcEnd
// We are on the circle, ensure we are only on the arc, i.e. between
// m_ArcStart and m_ArcEnd
int astart = t1; // arc starting point ( in 0.1 degree)
int aend = t2; // arc ending point ( in 0.1 degree)
int atest = wxRound( atan2( (double) relpos.y, (double) relpos.x ) * 1800.0 / M_PI );
int atest = wxRound( atan2( (double) relpos.y,
(double) relpos.x ) * 1800.0 / M_PI );
NORMALIZE_ANGLE_180( atest );
NORMALIZE_ANGLE_180( astart );
NORMALIZE_ANGLE_180( aend );
@ -226,13 +230,14 @@ LibEDA_BaseStruct* LibDrawArc::DoGenCopy()
newitem->m_ArcStart = m_ArcStart;
newitem->m_ArcEnd = m_ArcEnd;
newitem->m_Rayon = m_Rayon;
newitem->t1 = t1;
newitem->t2 = t2;
newitem->m_Width = m_Width;
newitem->m_Unit = m_Unit;
newitem->m_Convert = m_Convert;
newitem->m_Flags = m_Flags;
newitem->m_Fill = m_Fill;
newitem->t1 = t1;
newitem->t2 = t2;
newitem->m_Width = m_Width;
newitem->m_Unit = m_Unit;
newitem->m_Convert = m_Convert;
newitem->m_Flags = m_Flags;
newitem->m_Fill = m_Fill;
return (LibEDA_BaseStruct*) newitem;
}
@ -240,10 +245,9 @@ LibEDA_BaseStruct* LibDrawArc::DoGenCopy()
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
*/
int LibDrawArc::GetPenSize( )
int LibDrawArc::GetPenSize()
{
int pensize = (m_Width == 0) ? g_DrawDefaultLineThickness : m_Width;
return pensize;
return ( m_Width == 0 ) ? g_DrawDefaultLineThickness : m_Width;
}
@ -254,11 +258,11 @@ void LibDrawArc::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
{
wxPoint pos1, pos2, posc;
int color = ReturnLayerColor( LAYER_DEVICE );
int color = ReturnLayerColor( LAYER_DEVICE );
if( aColor < 0 ) // Used normal color or selected color
{
if( (m_Selected & IS_SELECTED) )
if( ( m_Selected & IS_SELECTED ) )
color = g_ItemSelectetColor;
}
else
@ -284,8 +288,8 @@ void LibDrawArc::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
if( fill == FILLED_WITH_BG_BODYCOLOR )
GRFilledArc( &aPanel->m_ClipBox, aDC, posc.x, posc.y, pt1, pt2,
m_Rayon, GetPenSize( ), color,
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
m_Rayon, GetPenSize( ), color,
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
else if( fill == FILLED_SHAPE && !aData )
GRFilledArc( &aPanel->m_ClipBox, aDC, posc.x, posc.y, pt1, pt2,
m_Rayon, color, color );
@ -295,12 +299,10 @@ void LibDrawArc::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
GRArc( &aPanel->m_ClipBox, aDC, posc.x, posc.y, pt1, pt2,
m_Rayon, GetPenSize( ), color );
#else
GRArc1( &aPanel->m_ClipBox, aDC, pos1.x, pos1.y, pos2.x, pos2.y,
posc.x, posc.y, GetPenSize( ), color );
#endif
}
@ -325,9 +327,8 @@ EDA_Rect LibDrawArc::GetBoundingBox()
if( ( normStart == nullPoint ) || ( normEnd == nullPoint )
|| ( m_Rayon == 0 ) )
{
wxLogDebug( wxT(
"Invalid arc drawing definition, center(%d, %d) \
start(%d, %d), end(%d, %d), radius %d" ),
wxLogDebug( wxT("Invalid arc drawing definition, center(%d, %d) \
start(%d, %d), end(%d, %d), radius %d" ),
m_Pos.x, m_Pos.y, m_ArcStart.x, m_ArcStart.y, m_ArcEnd.x,
m_ArcEnd.y, m_Rayon );
return rect;
@ -469,7 +470,8 @@ bool LibDrawCircle::HitTest( wxPoint aPosRef, int aThreshold, const int aTransMa
wxPoint relpos = aPosRef - TransformCoordinate( aTransMat, m_Pos );
int dist =
wxRound( sqrt( ( (double) relpos.x * relpos.x ) + ( (double) relpos.y * relpos.y ) ) );
wxRound( sqrt( ( (double) relpos.x * relpos.x ) +
( (double) relpos.y * relpos.y ) ) );
if( abs( dist - m_Rayon ) <= aThreshold )
return true;
@ -488,6 +490,7 @@ LibEDA_BaseStruct* LibDrawCircle::DoGenCopy()
newitem->m_Convert = m_Convert;
newitem->m_Flags = m_Flags;
newitem->m_Fill = m_Fill;
return (LibEDA_BaseStruct*) newitem;
}
@ -495,10 +498,9 @@ LibEDA_BaseStruct* LibDrawCircle::DoGenCopy()
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
*/
int LibDrawCircle::GetPenSize( )
int LibDrawCircle::GetPenSize()
{
int pensize = (m_Width == 0) ? g_DrawDefaultLineThickness : m_Width;
return pensize;
return ( m_Width == 0 ) ? g_DrawDefaultLineThickness : m_Width;
}
@ -508,7 +510,7 @@ void LibDrawCircle::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
{
wxPoint pos1;
int color = ReturnLayerColor( LAYER_DEVICE );
int color = ReturnLayerColor( LAYER_DEVICE );
if( aColor < 0 ) // Used normal color or selected color
{
@ -527,8 +529,8 @@ void LibDrawCircle::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
if( fill == FILLED_WITH_BG_BODYCOLOR )
GRFilledCircle( &aPanel->m_ClipBox, aDC, pos1.x, pos1.y,
m_Rayon, GetPenSize( ), color,
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
m_Rayon, GetPenSize( ), color,
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
else if( fill == FILLED_SHAPE )
GRFilledCircle( &aPanel->m_ClipBox, aDC, pos1.x, pos1.y,
m_Rayon, 0, color, color );
@ -630,6 +632,7 @@ LibEDA_BaseStruct* LibDrawSquare::DoGenCopy()
newitem->m_Convert = m_Convert;
newitem->m_Flags = m_Flags;
newitem->m_Fill = m_Fill;
return (LibEDA_BaseStruct*) newitem;
}
@ -637,10 +640,9 @@ LibEDA_BaseStruct* LibDrawSquare::DoGenCopy()
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
*/
int LibDrawSquare::GetPenSize( )
int LibDrawSquare::GetPenSize()
{
int pensize = (m_Width == 0) ? g_DrawDefaultLineThickness : m_Width;
return pensize;
return ( m_Width == 0 ) ? g_DrawDefaultLineThickness : m_Width;
}
void LibDrawSquare::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
@ -649,7 +651,7 @@ void LibDrawSquare::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
{
wxPoint pos1, pos2;
int color = ReturnLayerColor( LAYER_DEVICE );
int color = ReturnLayerColor( LAYER_DEVICE );
if( aColor < 0 ) // Used normal color or selected color
{
@ -666,10 +668,12 @@ void LibDrawSquare::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
if( aColor >= 0 )
fill = NO_FILL;
GRSetDrawMode( aDC, aDrawMode );
if( fill == FILLED_WITH_BG_BODYCOLOR && !aData )
GRFilledRect( &aPanel->m_ClipBox, aDC, pos1.x, pos1.y, pos2.x, pos2.y,
GetPenSize( ), color,
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
GetPenSize( ), color,
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
else if( m_Fill == FILLED_SHAPE && !aData )
GRFilledRect( &aPanel->m_ClipBox, aDC, pos1.x, pos1.y, pos2.x, pos2.y,
GetPenSize( ), color, color );
@ -724,10 +728,12 @@ bool LibDrawSquare::HitTest( const wxPoint& aRefPoint )
/** Function HitTest
* @return true if the point aPosRef is near this object
* @param aRefPoint = a wxPoint to test
* @param aThreshold = max distance to this object (usually the half thickness of a line)
* @param aThreshold = max distance to this object (usually the half thickness
* of a line)
* @param aTransMat = the transform matrix
*/
bool LibDrawSquare::HitTest( wxPoint aRefPoint, int aThreshold, const int aTransMat[2][2] )
bool LibDrawSquare::HitTest( wxPoint aRefPoint, int aThreshold,
const int aTransMat[2][2] )
{
wxPoint actualStart = TransformCoordinate( aTransMat, m_Pos );
wxPoint actualEnd = TransformCoordinate( aTransMat, m_End );
@ -798,6 +804,7 @@ LibEDA_BaseStruct* LibDrawSegment::DoGenCopy()
newitem->m_Unit = m_Unit;
newitem->m_Convert = m_Convert;
newitem->m_Flags = m_Flags;
return (LibEDA_BaseStruct*) newitem;
}
@ -805,10 +812,9 @@ LibEDA_BaseStruct* LibDrawSegment::DoGenCopy()
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
*/
int LibDrawSegment::GetPenSize( )
int LibDrawSegment::GetPenSize()
{
int pensize = (m_Width == 0) ? g_DrawDefaultLineThickness : m_Width;
return pensize;
return ( m_Width == 0 ) ? g_DrawDefaultLineThickness : m_Width;
}
void LibDrawSegment::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
@ -817,7 +823,7 @@ void LibDrawSegment::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
{
wxPoint pos1, pos2;
int color = ReturnLayerColor( LAYER_DEVICE );
int color = ReturnLayerColor( LAYER_DEVICE );
if( aColor < 0 ) // Used normal color or selected color
{
@ -830,6 +836,8 @@ void LibDrawSegment::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
pos1 = TransformCoordinate( aTransformMatrix, m_Pos ) + aOffset;
pos2 = TransformCoordinate( aTransformMatrix, m_End ) + aOffset;
GRSetDrawMode( aDC, aDrawMode );
GRLine( &aPanel->m_ClipBox, aDC, pos1.x, pos1.y, pos2.x, pos2.y,
GetPenSize( ), color );
}
@ -875,10 +883,12 @@ bool LibDrawSegment::HitTest( const wxPoint& aPosRef )
/** Function HitTest
* @return true if the point aPosRef is near this object
* @param aPosRef = a wxPoint to test
* @param aThreshold = max distance to this object (usually the half thickness of a line)
* @param aThreshold = max distance to this object (usually the half
* thickness of a line)
* @param aTransMat = the transform matrix
*/
bool LibDrawSegment::HitTest( wxPoint aPosRef, int aThreshold, const int aTransMat[2][2] )
bool LibDrawSegment::HitTest( wxPoint aPosRef, int aThreshold,
const int aTransMat[2][2] )
{
wxPoint start = TransformCoordinate( aTransMat, m_Pos );
wxPoint end = TransformCoordinate( aTransMat, m_End );
@ -981,11 +991,12 @@ LibEDA_BaseStruct* LibDrawPolyline::DoGenCopy()
LibDrawPolyline* newitem = new LibDrawPolyline( GetParent() );
newitem->m_PolyPoints = m_PolyPoints; // Vector copy
newitem->m_Width = m_Width;
newitem->m_Unit = m_Unit;
newitem->m_Convert = m_Convert;
newitem->m_Flags = m_Flags;
newitem->m_Fill = m_Fill;
newitem->m_Width = m_Width;
newitem->m_Unit = m_Unit;
newitem->m_Convert = m_Convert;
newitem->m_Flags = m_Flags;
newitem->m_Fill = m_Fill;
return (LibEDA_BaseStruct*) newitem;
}
@ -999,10 +1010,9 @@ void LibDrawPolyline::AddPoint( const wxPoint& point )
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
*/
int LibDrawPolyline::GetPenSize( )
int LibDrawPolyline::GetPenSize()
{
int pensize = (m_Width == 0) ? g_DrawDefaultLineThickness : m_Width;
return pensize;
return ( m_Width == 0 ) ? g_DrawDefaultLineThickness : m_Width;
}
void LibDrawPolyline::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
@ -1010,8 +1020,7 @@ void LibDrawPolyline::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
void* aData, const int aTransformMatrix[2][2] )
{
wxPoint pos1;
int color = ReturnLayerColor( LAYER_DEVICE );
int color = ReturnLayerColor( LAYER_DEVICE );
// Buffer used to store current corners coordinates for drawings
static wxPoint* Buf_Poly_Drawings = NULL;
@ -1050,10 +1059,12 @@ void LibDrawPolyline::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
if( aColor >= 0 )
fill = NO_FILL;
GRSetDrawMode( aDC, aDrawMode );
if( fill == FILLED_WITH_BG_BODYCOLOR )
GRPoly( &aPanel->m_ClipBox, aDC, m_PolyPoints.size(),
Buf_Poly_Drawings, 1, GetPenSize( ), color,
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
Buf_Poly_Drawings, 1, GetPenSize( ), color,
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
else if( fill == FILLED_SHAPE )
GRPoly( &aPanel->m_ClipBox, aDC, m_PolyPoints.size(),
Buf_Poly_Drawings, 1, GetPenSize( ), color, color );
@ -1169,7 +1180,8 @@ bool LibDrawBezier::Save( FILE* ExportFile ) const
for( unsigned i = 0; i < GetCornerCount(); i++ )
{
fprintf( ExportFile, " %d %d", m_BezierPoints[i].x, m_BezierPoints[i].y );
fprintf( ExportFile, " %d %d", m_BezierPoints[i].x,
m_BezierPoints[i].y );
}
fprintf( ExportFile, " %c\n", fill_tab[m_Fill] );
@ -1185,17 +1197,18 @@ bool LibDrawBezier::Load( char* line, wxString& errorMsg )
wxPoint pt;
i = sscanf( &line[2], "%d %d %d %d", &ccount, &m_Unit, &m_Convert,
&m_Width );
&m_Width );
if( i !=4 )
{
errorMsg.Printf( _( "Bezier only had %d parameters of the required 4" ), i );
errorMsg.Printf( _( "Bezier only had %d parameters of the required 4" ),
i );
return false;
}
if( ccount <= 0 )
{
errorMsg.Printf( _( "Bezier count parameter %d is invalid" ),
ccount );
ccount );
return false;
}
@ -1210,15 +1223,13 @@ bool LibDrawBezier::Load( char* line, wxString& errorMsg )
p = strtok( NULL, " \t\n" );
if( sscanf( p, "%d", &pt.x ) != 1 )
{
errorMsg.Printf( _( "Bezier point %d X position not defined" ),
i );
errorMsg.Printf( _( "Bezier point %d X position not defined" ), i );
return false;
}
p = strtok( NULL, " \t\n" );
if( sscanf( p, "%d", &pt.y ) != 1 )
{
errorMsg.Printf( _( "Bezier point %d Y position not defined" ),
i );
errorMsg.Printf( _( "Bezier point %d Y position not defined" ), i );
return false;
}
m_BezierPoints.push_back( pt );
@ -1254,29 +1265,30 @@ LibEDA_BaseStruct* LibDrawBezier::DoGenCopy()
/** Function GetPenSize
* @return the size of the "pen" that be used to draw or plot this item
*/
int LibDrawBezier::GetPenSize( )
int LibDrawBezier::GetPenSize()
{
int pensize = (m_Width == 0) ? g_DrawDefaultLineThickness : m_Width;
return pensize;
return ( m_Width == 0 ) ? g_DrawDefaultLineThickness : m_Width;
}
void LibDrawBezier::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
const wxPoint& aOffset, int aColor, int aDrawMode,
void* aData, const int aTransformMatrix[2][2] )
const wxPoint& aOffset, int aColor, int aDrawMode,
void* aData, const int aTransformMatrix[2][2] )
{
wxPoint pos1;
std::vector<wxPoint> PolyPointsTraslated;
wxPoint pos1;
std::vector<wxPoint> PolyPointsTraslated;
int color = ReturnLayerColor( LAYER_DEVICE );
int color = ReturnLayerColor( LAYER_DEVICE );
m_PolyPoints = Bezier2Poly( m_BezierPoints[0] ,
m_BezierPoints[1] ,
m_BezierPoints[2] ,
m_BezierPoints[3]);
m_PolyPoints = Bezier2Poly( m_BezierPoints[0],
m_BezierPoints[1],
m_BezierPoints[2],
m_BezierPoints[3] );
PolyPointsTraslated.clear();
for( unsigned int i = 0; i < m_PolyPoints.size() ; i++)
PolyPointsTraslated.push_back( TransformCoordinate( aTransformMatrix, m_PolyPoints[i] ) + aOffset);
PolyPointsTraslated.clear();
for( unsigned int i = 0; i < m_PolyPoints.size() ; i++ )
PolyPointsTraslated.push_back(
TransformCoordinate( aTransformMatrix, m_PolyPoints[i] ) + aOffset );
if( aColor < 0 ) // Used normal color or selected color
{
@ -1290,16 +1302,18 @@ void LibDrawBezier::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
if( aColor >= 0 )
fill = NO_FILL;
GRSetDrawMode( aDC, aDrawMode );
if( fill == FILLED_WITH_BG_BODYCOLOR )
GRPoly( &aPanel->m_ClipBox, aDC, m_PolyPoints.size(),
&PolyPointsTraslated[0], 1, GetPenSize( ), color,
&PolyPointsTraslated[0], 1, GetPenSize(), color,
ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
else if( fill == FILLED_SHAPE )
GRPoly( &aPanel->m_ClipBox, aDC, m_PolyPoints.size(),
&PolyPointsTraslated[0], 1, GetPenSize( ), color, color );
&PolyPointsTraslated[0], 1, GetPenSize(), color, color );
else
GRPoly( &aPanel->m_ClipBox, aDC, m_PolyPoints.size(),
&PolyPointsTraslated[0], 0, GetPenSize( ), color, color );
&PolyPointsTraslated[0], 0, GetPenSize(), color, color );
}
@ -1326,7 +1340,7 @@ bool LibDrawBezier::HitTest( const wxPoint& aRefPos )
* @param aTransMat = the transform matrix
*/
bool LibDrawBezier::HitTest( wxPoint aPosRef, int aThreshold,
const int aTransMat[2][2] )
const int aTransMat[2][2] )
{
wxPoint ref, start, end;
@ -1334,6 +1348,7 @@ bool LibDrawBezier::HitTest( wxPoint aPosRef, int aThreshold,
{
start = TransformCoordinate( aTransMat, m_PolyPoints[ii - 1] );
end = TransformCoordinate( aTransMat, m_PolyPoints[ii] );
if ( TestSegmentHit( aPosRef, start, end, aThreshold ) )
return true;
}
@ -1349,8 +1364,10 @@ EDA_Rect LibDrawBezier::GetBoundingBox()
{
EDA_Rect rect;
int xmin, xmax, ymin, ymax;
if(!GetCornerCount())
return rect;
if( !GetCornerCount() )
return rect;
xmin = xmax = m_PolyPoints[0].x;
ymin = ymax = m_PolyPoints[0].y;
@ -1378,12 +1395,12 @@ void LibDrawBezier::DisplayInfo( WinEDA_DrawFrame* frame )
LibEDA_BaseStruct::DisplayInfo( frame );
msg = ReturnStringFromValue( g_UnitMetric, m_Width,
EESCHEMA_INTERNAL_UNIT, true );
EESCHEMA_INTERNAL_UNIT, true );
frame->MsgPanel->Affiche_1_Parametre( 20, _( "Line width" ), msg, BLUE );
msg.Printf( wxT( "(%d, %d, %d, %d)" ), bBox.GetOrigin().x,
bBox.GetOrigin().y, bBox.GetEnd().x, bBox.GetEnd().y );
bBox.GetOrigin().y, bBox.GetEnd().x, bBox.GetEnd().y );
frame->MsgPanel->Affiche_1_Parametre( 40, _( "Bounding box" ), msg, BROWN );
}

27
eeschema/classes_body_items.h
View File

@ -77,19 +77,6 @@ enum DrawPinOrient {
PIN_DOWN = 'D',
};
// Struct to pass parameters for drawing pins, in function Draw
class DrawPinPrms
{
public:
EDA_LibComponentStruct* m_Entry; // Pointer to the component in lib
bool m_DrawPinText; // Are pin texts drawn ?
DrawPinPrms( EDA_LibComponentStruct* entry, bool drawpintext = true )
{
m_Entry = entry;
m_DrawPinText = drawpintext;
}
};
/****************************************************************************/
/* Classes for handle the body items of a component: pins add graphic items */
@ -103,11 +90,11 @@ public:
class LibEDA_BaseStruct : public EDA_BaseStruct
{
public:
int m_Unit; /* Unit identification (for multi part per package)
int m_Unit; /* Unit identification (for multi part per package)
* 0 if the item is common to all units */
int m_Convert; /* Shape identification (for parts which have a convert
int m_Convert; /* Shape identification (for parts which have a convert
* shape) 0 if the item is common to all shapes */
FILL_T m_Fill; /* NO_FILL, FILLED_SHAPE or FILLED_WITH_BG_BODYCOLOR.
FILL_T m_Fill; /* NO_FILL, FILLED_SHAPE or FILLED_WITH_BG_BODYCOLOR.
* has meaning only for some items */
wxString m_typeName; /* Name of object displayed in the message panel. */
@ -227,11 +214,11 @@ public:
/* (Currently Unused) Pin num and Pin name text options: italic/normal
* /bold, 0 = default */
char m_PinNumShapeOpt;
char m_PinNameShapeOpt;
char m_PinNumShapeOpt;
char m_PinNameShapeOpt;
// (Currently Unused) Pin num and Pin name text opt position, 0 = default:
char m_PinNumPositionOpt;
char m_PinNamePositionOpt;
char m_PinNumPositionOpt;
char m_PinNamePositionOpt;
wxPoint m_Pos; /* Position or centre (Arc and Circle) or start
* point (segments) */

236
eeschema/delete.cpp
View File

@ -13,21 +13,20 @@
#include "class_marker_sch.h"
// Imported function:
void DeleteItemsInList( WinEDA_DrawPanel* panel,
PICKED_ITEMS_LIST& aItemsList );
void DeleteItemsInList( WinEDA_DrawPanel* panel,
PICKED_ITEMS_LIST& aItemsList );
/********************************************************************************/
static int CountConnectedItems( WinEDA_SchematicFrame* frame,
SCH_ITEM* ListStruct, wxPoint pos, bool TstJunction )
/********************************************************************************/
/* Count number of items connected to point pos :
* pins, end wire or bus, and junctions if TstJunction == TRUE
* Return this count
/*
* Count number of items connected to point pos :
* pins, end wire or bus, and junctions if TstJunction == TRUE
* Return this count
*
* Used by WinEDA_SchematicFrame::DeleteConnection()
* Used by WinEDA_SchematicFrame::DeleteConnection()
*/
static int CountConnectedItems( WinEDA_SchematicFrame* frame,
SCH_ITEM* ListStruct, wxPoint pos,
bool TstJunction )
{
SCH_ITEM* Struct;
int count = 0;
@ -64,16 +63,16 @@ static int CountConnectedItems( WinEDA_SchematicFrame* frame,
}
/************************************************************************************/
/*
* Mark to "CANDIDATE" all wires or junction connected to "segment" in list
* "ListStruct"
* Search wire stop at an any pin
*
* Used by WinEDA_SchematicFrame::DeleteConnection()
*/
static bool MarkConnected( WinEDA_SchematicFrame* frame, SCH_ITEM* ListStruct,
EDA_DrawLineStruct* segment )
/************************************************************************************/
/* Mark to "CANDIDATE" all wires or junction connected to "segment" in list "ListStruct"
* Search wire stop at an any pin
*
* Used by WinEDA_SchematicFrame::DeleteConnection()
*/
{
EDA_BaseStruct* Struct;
@ -117,34 +116,34 @@ static bool MarkConnected( WinEDA_SchematicFrame* frame, SCH_ITEM* ListStruct,
}
/********************************************************************************/
void WinEDA_SchematicFrame::DeleteConnection( bool DeleteFullConnection )
/********************************************************************************/
/* Delete a connection, i.e wires or bus connected
* stop on a node (more than 2 wires (bus) connected)
/*
* Delete a connection, i.e wires or bus connected
* stop on a node (more than 2 wires (bus) connected)
*/
void WinEDA_SchematicFrame::DeleteConnection( bool DeleteFullConnection )
{
wxPoint refpos = GetScreen()->m_Curseur;
SCH_ITEM* DelStruct;
PICKED_ITEMS_LIST pickList;
/* Clear .m_Flags member for all items */
for( DelStruct = GetScreen()->EEDrawList; DelStruct != NULL; DelStruct = DelStruct->Next() )
for( DelStruct = GetScreen()->EEDrawList; DelStruct != NULL;
DelStruct = DelStruct->Next() )
DelStruct->m_Flags = 0;
BreakSegmentOnJunction( (SCH_SCREEN*) GetScreen() );
/* Locate all the wires, bus or junction under the mouse cursor, and put them in a list
* of items to delete
/* Locate all the wires, bus or junction under the mouse cursor, and put
* them in a list of items to delete
*/
ITEM_PICKER picker(NULL, UR_DELETED);
SCH_SCREEN* screen = (SCH_SCREEN*) GetScreen();
SCH_ITEM* savedEEDrawList = screen->EEDrawList; // Save the list entry point of this screen
// Save the list entry point of this screen
SCH_ITEM* savedEEDrawList = screen->EEDrawList;
DelStruct = GetScreen()->EEDrawList;
while( DelStruct
&& ( DelStruct = PickStruct( screen->m_Curseur,
screen, JUNCTIONITEM | WIREITEM | BUSITEM ) ) != NULL )
&& ( DelStruct = PickStruct( screen->m_Curseur, screen,
JUNCTIONITEM | WIREITEM | BUSITEM ) ) != NULL )
{
DelStruct->m_Flags = SELECTEDNODE | STRUCT_DELETED;
@ -163,7 +162,8 @@ void WinEDA_SchematicFrame::DeleteConnection( bool DeleteFullConnection )
*/
if( DeleteFullConnection )
{
for( DelStruct = GetScreen()->EEDrawList; DelStruct != NULL; DelStruct = DelStruct->Next() )
for( DelStruct = GetScreen()->EEDrawList; DelStruct != NULL;
DelStruct = DelStruct->Next() )
{
if( !(DelStruct->m_Flags & SELECTEDNODE) )
continue;
@ -177,15 +177,16 @@ void WinEDA_SchematicFrame::DeleteConnection( bool DeleteFullConnection )
}
// Search all removable wires (i.e wire with one new dangling end )
for( DelStruct = GetScreen()->EEDrawList; DelStruct != NULL; DelStruct = DelStruct->Next() )
for( DelStruct = GetScreen()->EEDrawList; DelStruct != NULL;
DelStruct = DelStruct->Next() )
{
bool noconnect = FALSE;
if( DelStruct->m_Flags & STRUCT_DELETED )
continue; // Already seen
continue; // Already seen
if( !(DelStruct->m_Flags & CANDIDATE) )
continue; // Already seen
continue; // Already seen
if( DelStruct->Type() != DRAW_SEGMENT_STRUCT_TYPE )
continue;
@ -193,8 +194,9 @@ void WinEDA_SchematicFrame::DeleteConnection( bool DeleteFullConnection )
DelStruct->m_Flags |= SKIP_STRUCT;
#define SEGM ( (EDA_DrawLineStruct*) DelStruct )
/* Test the SEGM->m_Start point: if this point was connected to an STRUCT_DELETED wire,
* and now is not connected, the wire can be deleted */
/* Test the SEGM->m_Start point: if this point was connected to
* an STRUCT_DELETED wire, and now is not connected, the wire can
* be deleted */
EDA_BaseStruct* removed_struct;
for( removed_struct = GetScreen()->EEDrawList;
removed_struct != NULL;
@ -211,11 +213,13 @@ void WinEDA_SchematicFrame::DeleteConnection( bool DeleteFullConnection )
break;
}
if( WIRE && !CountConnectedItems( this, GetScreen()->EEDrawList, SEGM->m_Start, TRUE ) )
if( WIRE && !CountConnectedItems( this, GetScreen()->EEDrawList,
SEGM->m_Start, TRUE ) )
noconnect = TRUE;
/* Test the SEGM->m_End point: if this point was connected to an STRUCT_DELETED wire,
* and now is not connected, the wire can be deleted */
/* Test the SEGM->m_End point: if this point was connected to
* an STRUCT_DELETED wire, and now is not connected, the wire
* can be deleted */
for( removed_struct = GetScreen()->EEDrawList;
removed_struct != NULL;
removed_struct = removed_struct->Next() )
@ -229,7 +233,8 @@ void WinEDA_SchematicFrame::DeleteConnection( bool DeleteFullConnection )
}
if( removed_struct &&
!CountConnectedItems( this, GetScreen()->EEDrawList, SEGM->m_End, TRUE ) )
!CountConnectedItems( this, GetScreen()->EEDrawList,
SEGM->m_End, TRUE ) )
noconnect = TRUE;
DelStruct->m_Flags &= ~SKIP_STRUCT;
@ -247,8 +252,10 @@ void WinEDA_SchematicFrame::DeleteConnection( bool DeleteFullConnection )
#undef SEGM
}
// Delete redundant junctions (junctions which connect < 3 end wires and no pin are removed)
for( DelStruct = GetScreen()->EEDrawList; DelStruct != NULL; DelStruct = DelStruct->Next() )
// Delete redundant junctions (junctions which connect < 3 end wires
// and no pin are removed)
for( DelStruct = GetScreen()->EEDrawList; DelStruct != NULL;
DelStruct = DelStruct->Next() )
{
int count;
if( DelStruct->m_Flags & STRUCT_DELETED )
@ -260,7 +267,8 @@ void WinEDA_SchematicFrame::DeleteConnection( bool DeleteFullConnection )
if( DelStruct->Type() == DRAW_JUNCTION_STRUCT_TYPE )
{
#define JUNCTION ( (DrawJunctionStruct*) DelStruct )
count = CountConnectedItems( this, GetScreen()->EEDrawList, JUNCTION->m_Pos, FALSE );
count = CountConnectedItems( this, GetScreen()->EEDrawList,
JUNCTION->m_Pos, FALSE );
if( count <= 2 )
{
DelStruct->m_Flags |= STRUCT_DELETED;
@ -276,7 +284,8 @@ void WinEDA_SchematicFrame::DeleteConnection( bool DeleteFullConnection )
// Delete labels attached to wires
wxPoint pos = GetScreen()->m_Curseur;
for( DelStruct = GetScreen()->EEDrawList; DelStruct != NULL; DelStruct = DelStruct->Next() )
for( DelStruct = GetScreen()->EEDrawList; DelStruct != NULL;
DelStruct = DelStruct->Next() )
{
if( DelStruct->m_Flags & STRUCT_DELETED )
continue;
@ -286,7 +295,8 @@ void WinEDA_SchematicFrame::DeleteConnection( bool DeleteFullConnection )
GetScreen()->m_Curseur = ( (SCH_TEXT*) DelStruct )->m_Pos;
EDA_BaseStruct* TstStruct =
PickStruct( GetScreen()->m_Curseur, GetScreen(), WIREITEM | BUSITEM );
PickStruct( GetScreen()->m_Curseur, GetScreen(),
WIREITEM | BUSITEM );
if( TstStruct && TstStruct->m_Flags & STRUCT_DELETED )
{
@ -302,7 +312,8 @@ void WinEDA_SchematicFrame::DeleteConnection( bool DeleteFullConnection )
GetScreen()->m_Curseur = pos;
}
for( DelStruct = GetScreen()->EEDrawList; DelStruct != NULL; DelStruct = DelStruct->Next() )
for( DelStruct = GetScreen()->EEDrawList; DelStruct != NULL;
DelStruct = DelStruct->Next() )
DelStruct->m_Flags = 0;
if( pickList.GetCount() )
@ -313,23 +324,21 @@ void WinEDA_SchematicFrame::DeleteConnection( bool DeleteFullConnection )
}
/*****************************************************************/
bool LocateAndDeleteItem( WinEDA_SchematicFrame* frame, wxDC* DC )
/*****************************************************************/
/* Locate and delete the item found under the mouse cousor
* If more than one item found: the priority order is:
* 1 : MARKER
* 2 : JUNCTION
* 2 : NOCONNECT
* 3 : WIRE ou BUS
* 4 : DRAWITEM
* 5 : TEXT
* 6 : COMPOSANT
* 7 : SHEET
/*
* Locate and delete the item found under the mouse cousor
* If more than one item found: the priority order is:
* 1 : MARKER
* 2 : JUNCTION
* 2 : NOCONNECT
* 3 : WIRE ou BUS
* 4 : DRAWITEM
* 5 : TEXT
* 6 : COMPOSANT
* 7 : SHEET
*
* return TRUE if an item was deleted
* return TRUE if an item was deleted
*/
bool LocateAndDeleteItem( WinEDA_SchematicFrame* frame, wxDC* DC )
{
SCH_ITEM* DelStruct;
SCH_SCREEN* screen = (SCH_SCREEN*) ( frame->GetScreen() );
@ -347,7 +356,8 @@ bool LocateAndDeleteItem( WinEDA_SchematicFrame* frame, wxDC* DC )
if( DelStruct == NULL )
DelStruct = PickStruct( screen->m_Curseur, screen, DRAWITEM );
if( DelStruct == NULL )
DelStruct = PickStruct( screen->m_Curseur, screen, TEXTITEM | LABELITEM );
DelStruct = PickStruct( screen->m_Curseur, screen,
TEXTITEM | LABELITEM );
if( DelStruct == NULL )
DelStruct = PickStruct( screen->m_Curseur, screen, LIBITEM );
if( DelStruct == NULL )
@ -366,21 +376,19 @@ bool LocateAndDeleteItem( WinEDA_SchematicFrame* frame, wxDC* DC )
}
/***************************************************************/
void EraseStruct( SCH_ITEM* DrawStruct, SCH_SCREEN* Screen )
/***************************************************************/
/* Suppression definitive d'une structure dans une liste chainee
* d'elements de dessin
* DrawStruct = pointeur sur la structure
* Screen = pointeur sur l'ecran d'appartenance
* Le chainage de la liste est modifie.
/*
* Suppression definitive d'une structure dans une liste chainee
* d'elements de dessin
* DrawStruct = pointeur sur la structure
* Screen = pointeur sur l'ecran d'appartenance
* Le chainage de la liste est modifie.
*
* Remarque:
* pour les structures DRAW_SHEET_STRUCT_TYPE, l'ecran et les structures
* correspondantes ne sont pas touches.
* Ils doivent etre traites separement
* Remarque:
* pour les structures DRAW_SHEET_STRUCT_TYPE, l'ecran et les structures
* correspondantes ne sont pas touches.
* Ils doivent etre traites separement
*/
void EraseStruct( SCH_ITEM* DrawStruct, SCH_SCREEN* Screen )
{
EDA_BaseStruct* DrawList;
Hierarchical_PIN_Sheet_Struct* SheetLabel, * NextLabel;
@ -419,20 +427,23 @@ void EraseStruct( SCH_ITEM* DrawStruct, SCH_SCREEN* Screen )
{
while( SheetLabel->Next() ) /* Examen de la liste dependante */
{
NextLabel = (Hierarchical_PIN_Sheet_Struct*) SheetLabel->Next();
NextLabel =
(Hierarchical_PIN_Sheet_Struct*) SheetLabel->Next();
if( NextLabel == (Hierarchical_PIN_Sheet_Struct*) DrawStruct )
{
SheetLabel->SetNext( (EDA_BaseStruct*) NextLabel->Next() );
SAFE_DELETE( DrawStruct );
return;
}
SheetLabel = NextLabel;
}
}
}
return;
}
else // structure usuelle */
{
if( DrawStruct == Screen->EEDrawList )
@ -458,10 +469,10 @@ void EraseStruct( SCH_ITEM* DrawStruct, SCH_SCREEN* Screen )
}
/********************************/
/*
* Effacement des marqueurs du type "type"
*/
void DeleteAllMarkers( int type )
/********************************/
/* Effacement des marqueurs du type "type" */
{
SCH_SCREEN* screen;
SCH_ITEM * DrawStruct, * NextStruct;
@ -469,9 +480,11 @@ void DeleteAllMarkers( int type )
EDA_ScreenList ScreenList;
for( screen = ScreenList.GetFirst(); screen != NULL; screen = ScreenList.GetNext() )
for( screen = ScreenList.GetFirst(); screen != NULL;
screen = ScreenList.GetNext() )
{
for( DrawStruct = screen->EEDrawList; DrawStruct != NULL; DrawStruct = NextStruct )
for( DrawStruct = screen->EEDrawList; DrawStruct != NULL;
DrawStruct = NextStruct )
{
NextStruct = DrawStruct->Next();
if( DrawStruct->Type() != TYPE_MARKER_SCH )
@ -487,60 +500,3 @@ void DeleteAllMarkers( int type )
}
}
}
/********************************************************************/
void DeleteOneLibraryDrawStruct( WinEDA_DrawPanel* panel, wxDC* DC,
EDA_LibComponentStruct* LibEntry,
LibEDA_BaseStruct* DrawItem, int Affiche )
/********************************************************************/
/* Routine d'effacement d'un "LibraryDrawStruct"
* (d'un element de dessin d'un composant )
*
* Parametres d'entree
* Pointeur sur le composant comportant la structure
* (Si NULL la structure a effacer est supposee non rattachee
* a un composant)
* Pointeur sur la structure a effacer
*
* Efface egalement le graphique correspondant de l'ecran
*/
{
LibEDA_BaseStruct* PreviousDrawItem;
/* Effacement du graphique */
if( Affiche && DC )
DrawLibraryDrawStruct( panel, DC, LibEntry, wxPoint(0, 0), DrawItem, g_XorMode );
/* Effacement de la structure en memoire */
if( LibEntry ) /* Recherche du predecesseur */
{
PreviousDrawItem = LibEntry->m_Drawings;
/* Cas du 1er symbole graphique = struct a supprimer */
if( LibEntry->m_Drawings == DrawItem )
{
LibEntry->m_Drawings = DrawItem->Next();
SAFE_DELETE( DrawItem );
}
else /* Cas des autres items */
{
while( PreviousDrawItem )
{
if( PreviousDrawItem->Next() == DrawItem )
{
PreviousDrawItem->SetNext( DrawItem->Next() );
SAFE_DELETE( DrawItem );
break;
}
PreviousDrawItem = PreviousDrawItem->Next();
}
}
}
else /* Structure non reliee a un composant */
{
SAFE_DELETE( DrawItem );
}
}

13
eeschema/edit_component_in_lib.cpp
View File

@ -1,5 +1,5 @@
/**************************************************************/
/* librairy editor: edition of component general properties */
/* librairy editor: edition of component general properties */
/**************************************************************/
#include "fctsys.h"
@ -434,8 +434,8 @@ bool DIALOG_EDIT_COMPONENT_IN_LIBRARY::ChangeNbUnitsPerPackage( int MaxUnit )
return FALSE;
}
}
DeleteOneLibraryDrawStruct( m_Parent->DrawPanel, NULL, CurrentLibEntry,
DrawItem, 0 );
CurrentLibEntry->RemoveDrawItem( DrawItem );
}
}
@ -529,12 +529,9 @@ bool DIALOG_EDIT_COMPONENT_IN_LIBRARY::SetUnsetConvert()
return FALSE;
}
}
m_Parent->GetScreen()->SetModify();
DeleteOneLibraryDrawStruct( m_Parent->DrawPanel,
NULL,
CurrentLibEntry,
DrawItem,
0 );
CurrentLibEntry->RemoveDrawItem( DrawItem );
}
}
}

300
eeschema/edit_graphic_bodyitem_text.cpp
View File

@ -1,10 +1,10 @@
/**********************************************/
/* EESchema - symbtext.cpp for Library Editor */
/**********************************************/
/**********************************************/
/* EESchema - symbtext.cpp for Library Editor */
/**********************************************/
/* Menu et routines de creation, modification, suppression de textes
du type symbole
(textes autres que Fields)
du type symbole
(textes autres que Fields)
*/
#include "fctsys.h"
@ -24,25 +24,25 @@
class Dialog_BodyGraphicText_Properties : public Dialog_BodyGraphicText_Properties_base
{
private:
WinEDA_LibeditFrame * m_Parent;
LibDrawText * m_GraphicText;
WinEDA_LibeditFrame * m_Parent;
LibDrawText * m_GraphicText;
public:
Dialog_BodyGraphicText_Properties( WinEDA_LibeditFrame* aParent, LibDrawText * aGraphicText);
~Dialog_BodyGraphicText_Properties() {};
Dialog_BodyGraphicText_Properties( WinEDA_LibeditFrame* aParent, LibDrawText * aGraphicText);
~Dialog_BodyGraphicText_Properties() {};
private:
void InitDialog( );
void OnOkClick( wxCommandEvent& event );
void OnCancelClick( wxCommandEvent& event );
void InitDialog( );
void OnOkClick( wxCommandEvent& event );
void OnCancelClick( wxCommandEvent& event );
};
Dialog_BodyGraphicText_Properties::Dialog_BodyGraphicText_Properties( WinEDA_LibeditFrame* aParent, LibDrawText * aGraphicText) :
Dialog_BodyGraphicText_Properties_base(aParent)
Dialog_BodyGraphicText_Properties_base(aParent)
{
m_Parent = aParent;
m_GraphicText = aGraphicText;
m_Parent = aParent;
m_GraphicText = aGraphicText;
InitDialog( );
}
@ -51,26 +51,32 @@ Dialog_BodyGraphicText_Properties::Dialog_BodyGraphicText_Properties( WinEDA_Li
void Dialog_BodyGraphicText_Properties::InitDialog( )
/*****************************************************/
{
wxString msg;
wxString msg;
SetFocus();
SetFocus();
if ( m_GraphicText )
{
msg = ReturnStringFromValue(g_UnitMetric, m_GraphicText->m_Size.x, m_Parent->m_InternalUnits);
m_TextSize->SetValue(msg);
m_TextValue->SetValue(m_GraphicText->m_Text);
if ( m_GraphicText->m_Unit == 0 ) m_CommonUnit->SetValue(TRUE);
if ( m_GraphicText->m_Convert == 0 ) m_CommonConvert->SetValue(TRUE);
if ( m_GraphicText->m_Orient == TEXT_ORIENT_VERT ) m_Orient->SetValue(TRUE);
int shape = 0;
if ( m_GraphicText->m_Italic)
shape = 1;
if ( m_GraphicText->m_Bold)
shape |= 2;
if ( m_GraphicText )
{
msg = ReturnStringFromValue(g_UnitMetric, m_GraphicText->m_Size.x,
m_Parent->m_InternalUnits);
m_TextSize->SetValue( msg );
m_TextValue->SetValue( m_GraphicText->m_Text );
if ( m_GraphicText->m_Unit == 0 )
m_CommonUnit->SetValue( TRUE );
if ( m_GraphicText->m_Convert == 0 )
m_CommonConvert->SetValue( TRUE );
if ( m_GraphicText->m_Orient == TEXT_ORIENT_VERT )
m_Orient->SetValue( TRUE );
int shape = 0;
if ( m_GraphicText->m_Italic )
shape = 1;
if ( m_GraphicText->m_Bold )
shape |= 2;
m_TextShapeOpt->SetSelection( shape );
m_TextShapeOpt->SetSelection(shape);
switch ( m_GraphicText->m_HJustify )
{
case GR_TEXT_HJUSTIFY_LEFT:
@ -89,31 +95,36 @@ wxString msg;
switch ( m_GraphicText->m_VJustify )
{
case GR_TEXT_VJUSTIFY_BOTTOM:
m_TextVJustificationOpt->SetSelection(0);
break;
case GR_TEXT_VJUSTIFY_BOTTOM:
m_TextVJustificationOpt->SetSelection(0);
break;
case GR_TEXT_VJUSTIFY_CENTER:
m_TextVJustificationOpt->SetSelection(1);
break;
case GR_TEXT_VJUSTIFY_TOP:
m_TextVJustificationOpt->SetSelection(2);
break;
case GR_TEXT_VJUSTIFY_CENTER:
m_TextVJustificationOpt->SetSelection(1);
break;
case GR_TEXT_VJUSTIFY_TOP:
m_TextVJustificationOpt->SetSelection(2);
break;
}
}
else
{
msg = ReturnStringFromValue(g_UnitMetric, g_LastTextSize, m_Parent->m_InternalUnits);
m_TextSize->SetValue(msg);
if ( ! g_FlDrawSpecificUnit ) m_CommonUnit->SetValue(TRUE);
if ( ! g_FlDrawSpecificConvert ) m_CommonConvert->SetValue(TRUE);
if ( g_LastTextOrient == TEXT_ORIENT_VERT ) m_Orient->SetValue(TRUE);
}
}
else
{
msg = ReturnStringFromValue( g_UnitMetric, g_LastTextSize,
m_Parent->m_InternalUnits );
m_TextSize->SetValue( msg );
if ( ! g_FlDrawSpecificUnit )
m_CommonUnit->SetValue( TRUE );
if ( ! g_FlDrawSpecificConvert )
m_CommonConvert->SetValue( TRUE );
if ( g_LastTextOrient == TEXT_ORIENT_VERT )
m_Orient->SetValue( TRUE );
}
msg = m_TextSizeText->GetLabel() + ReturnUnitSymbol();
m_TextSizeText->SetLabel( msg );
msg = m_TextSizeText->GetLabel() + ReturnUnitSymbol();
m_TextSizeText->SetLabel(msg);
if (GetSizer())
{
GetSizer()->SetSizeHints(this);
@ -135,71 +146,79 @@ void Dialog_BodyGraphicText_Properties::OnOkClick( wxCommandEvent& event )
{
wxString Line;
Line = m_TextValue->GetValue();
g_LastTextOrient = m_Orient->GetValue() ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ;
wxString msg = m_TextSize->GetValue();
g_LastTextSize = ReturnValueFromString(g_UnitMetric, msg, m_Parent->m_InternalUnits);
g_FlDrawSpecificConvert = m_CommonConvert->GetValue() ? FALSE : TRUE;
g_FlDrawSpecificUnit = m_CommonUnit->GetValue() ? FALSE : TRUE;
Line = m_TextValue->GetValue();
g_LastTextOrient = m_Orient->GetValue() ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ;
wxString msg = m_TextSize->GetValue();
g_LastTextSize = ReturnValueFromString(g_UnitMetric, msg,
m_Parent->m_InternalUnits);
g_FlDrawSpecificConvert = m_CommonConvert->GetValue() ? FALSE : TRUE;
g_FlDrawSpecificUnit = m_CommonUnit->GetValue() ? FALSE : TRUE;
if ( m_GraphicText )
{
if ( ! Line.IsEmpty() ) m_GraphicText->m_Text = Line;
else m_GraphicText->m_Text = wxT("[null]");
m_GraphicText->m_Size.x = m_GraphicText->m_Size.y = g_LastTextSize;
m_GraphicText->m_Orient = g_LastTextOrient;
if( g_FlDrawSpecificUnit ) m_GraphicText->m_Unit = CurrentUnit;
else m_GraphicText->m_Unit = 0;
if( g_FlDrawSpecificConvert ) m_GraphicText->m_Convert = CurrentConvert;
else m_GraphicText->m_Convert = 0;
if ( m_GraphicText )
{
if ( ! Line.IsEmpty() )
m_GraphicText->m_Text = Line;
else
m_GraphicText->m_Text = wxT("[null]");
if ( (m_TextShapeOpt->GetSelection() & 1 ) != 0 )
m_GraphicText->m_Italic = true;
else
m_GraphicText->m_Italic = false;
m_GraphicText->m_Size.x = m_GraphicText->m_Size.y = g_LastTextSize;
m_GraphicText->m_Orient = g_LastTextOrient;
if ( (m_TextShapeOpt->GetSelection() & 2 ) != 0 )
m_GraphicText->m_Bold = true;
else
m_GraphicText->m_Bold = false;
if( g_FlDrawSpecificUnit )
m_GraphicText->m_Unit = CurrentUnit;
else
m_GraphicText->m_Unit = 0;
if( g_FlDrawSpecificConvert )
m_GraphicText->m_Convert = CurrentConvert;
else
m_GraphicText->m_Convert = 0;
if ( (m_TextShapeOpt->GetSelection() & 1 ) != 0 )
m_GraphicText->m_Italic = true;
else
m_GraphicText->m_Italic = false;
if ( (m_TextShapeOpt->GetSelection() & 2 ) != 0 )
m_GraphicText->m_Bold = true;
else
m_GraphicText->m_Bold = false;
switch ( m_TextHJustificationOpt->GetSelection() )
{
case 0:
m_GraphicText->m_HJustify = GR_TEXT_HJUSTIFY_LEFT;
break;
case 0:
m_GraphicText->m_HJustify = GR_TEXT_HJUSTIFY_LEFT;
break;
case 1:
m_GraphicText->m_HJustify = GR_TEXT_HJUSTIFY_CENTER;
break;
case 2:
m_GraphicText->m_HJustify = GR_TEXT_HJUSTIFY_RIGHT;
break;
case 1:
m_GraphicText->m_HJustify = GR_TEXT_HJUSTIFY_CENTER;
break;
case 2:
m_GraphicText->m_HJustify = GR_TEXT_HJUSTIFY_RIGHT;
break;
}
switch ( m_TextVJustificationOpt->GetSelection() )
switch ( m_TextVJustificationOpt->GetSelection() )
{
case 0:
m_GraphicText->m_VJustify = GR_TEXT_VJUSTIFY_BOTTOM;
break;
case 0:
m_GraphicText->m_VJustify = GR_TEXT_VJUSTIFY_BOTTOM;
break;
case 1:
m_GraphicText->m_VJustify = GR_TEXT_VJUSTIFY_CENTER;
break;
case 2:
m_GraphicText->m_VJustify = GR_TEXT_VJUSTIFY_TOP;
break;
case 1:
m_GraphicText->m_VJustify = GR_TEXT_VJUSTIFY_CENTER;
break;
case 2:
m_GraphicText->m_VJustify = GR_TEXT_VJUSTIFY_TOP;
break;
}
}
Close();
}
Close();
if ( CurrentDrawItem )
CurrentDrawItem->DisplayInfo( m_Parent );
Close();
if ( CurrentDrawItem )
CurrentDrawItem->DisplayInfo( m_Parent );
Close();
}
@ -212,26 +231,28 @@ void WinEDA_LibeditFrame::EditSymbolText(wxDC * DC, LibEDA_BaseStruct * DrawItem
|| ( DrawItem->Type() != COMPONENT_GRAPHIC_TEXT_DRAW_TYPE ) )
return;
/* Effacement ancien texte */
if( DC)
DrawLibraryDrawStruct(DrawPanel, DC, CurrentLibEntry, wxPoint(0, 0),
DrawItem, DrawMode);
/* Effacement ancien texte */
if( DC)
DrawItem->Draw( DrawPanel, DC, wxPoint( 0, 0 ), -1, DrawMode, NULL,
DefaultTransformMatrix );
Dialog_BodyGraphicText_Properties * frame =
new Dialog_BodyGraphicText_Properties(this, (LibDrawText *) DrawItem);
frame->ShowModal(); frame->Destroy();
Dialog_BodyGraphicText_Properties * frame =
new Dialog_BodyGraphicText_Properties( this,
(LibDrawText *) DrawItem );
frame->ShowModal();
frame->Destroy();
GetScreen()->SetModify();
GetScreen()->SetModify();
/* Affichage nouveau texte */
if( DC )
{
if ( ( DrawItem->m_Flags & IS_MOVED ) == 0 )
DrawMode = GR_DEFAULT_DRAWMODE;
/* Affichage nouveau texte */
if( DC )
{
if ( (DrawItem->m_Flags & IS_MOVED) == 0 )
DrawMode = GR_DEFAULT_DRAWMODE;
DrawLibraryDrawStruct(DrawPanel, DC, CurrentLibEntry, wxPoint(0, 0),
DrawItem, DrawMode);
}
DrawItem->Draw( DrawPanel, DC, wxPoint( 0, 0 ), -1, DrawMode, NULL,
DefaultTransformMatrix );
}
}
@ -239,31 +260,32 @@ void WinEDA_LibeditFrame::EditSymbolText(wxDC * DC, LibEDA_BaseStruct * DrawItem
void WinEDA_LibeditFrame::RotateSymbolText(wxDC * DC)
/****************************************************/
/*
90 deg Graphic text Rotation .
90 deg Graphic text Rotation .
*/
{
LibDrawText * DrawItem = (LibDrawText *) CurrentDrawItem;
LibDrawText * DrawItem = (LibDrawText *) CurrentDrawItem;
if(DrawItem == NULL) return;
if( DrawItem == NULL )
return;
/* Erase drawing (can be within a move command) */
if ( DrawPanel->ManageCurseur == NULL)
DrawLibraryDrawStruct(DrawPanel, DC, CurrentLibEntry, wxPoint(0, 0),
DrawItem, g_XorMode);
else DrawPanel->ManageCurseur(DrawPanel, DC, FALSE);
/* Erase drawing (can be within a move command) */
if ( DrawPanel->ManageCurseur == NULL)
DrawItem->Draw( DrawPanel, DC, wxPoint( 0, 0 ), -1, g_XorMode, NULL,
DefaultTransformMatrix );
else
DrawPanel->ManageCurseur( DrawPanel, DC, FALSE );
if( DrawItem->m_Orient == TEXT_ORIENT_HORIZ)
DrawItem->m_Orient = TEXT_ORIENT_VERT;
else DrawItem->m_Orient = TEXT_ORIENT_HORIZ;
if( DrawItem->m_Orient == TEXT_ORIENT_HORIZ )
DrawItem->m_Orient = TEXT_ORIENT_VERT;
else
DrawItem->m_Orient = TEXT_ORIENT_HORIZ;
GetScreen()->SetModify();
/* Redraw item with new orient */
if ( DrawPanel->ManageCurseur == NULL)
DrawLibraryDrawStruct(DrawPanel, DC, CurrentLibEntry, wxPoint(0, 0),
DrawItem, GR_DEFAULT_DRAWMODE);
else DrawPanel->ManageCurseur(DrawPanel, DC, FALSE);
GetScreen()->SetModify();
/* Redraw item with new orient */
if ( DrawPanel->ManageCurseur == NULL )
DrawItem->Draw( DrawPanel, DC, wxPoint( 0, 0 ), -1, GR_DEFAULT_DRAWMODE,
NULL, DefaultTransformMatrix );
else
DrawPanel->ManageCurseur( DrawPanel, DC, FALSE );
}

163
eeschema/eelibs_draw_components.cpp
View File

@ -6,11 +6,9 @@
#include "gr_basic.h"
#include "common.h"
#include "class_drawpanel.h"
#include "drawtxt.h"
#include "program.h"
#include "libcmp.h"
#include "general.h"
#include "trigo.h"
#include "protos.h"
//#define DRAW_ARC_WITH_ANGLE // Used to select function to draw arcs
@ -42,117 +40,6 @@ wxPoint TransformCoordinate( const int aTransformMatrix[2][2],
}
/**************************************************************/
/* Routine de dessin d'un composant d'une librairie
* LibEntry = pointeur sur la description en librairie
* posX, posY = position du composant
* DrawMode = GrOR ..
* Color = 0 : dessin en vraies couleurs, sinon couleur = Color
*
* Une croix symbolise le point d'accrochage (ref position) du composant
*
* Le composant est toujours trace avec orientation 0
*/
/*************************************************************/
void DrawLibEntry( WinEDA_DrawPanel* panel, wxDC* DC,
EDA_LibComponentStruct* LibEntry,
const wxPoint& aOffset,
int Multi, int convert,
int DrawMode, int Color )
{
int color;
wxString Prefix;
LibDrawField* Field;
wxPoint text_pos;
DrawLibPartAux( panel, DC, NULL, LibEntry, aOffset,
DefaultTransformMatrix, Multi,
convert, DrawMode, Color );
/* Trace des 2 champs ref et value (Attention aux coord: la matrice
* de transformation change de signe les coord Y */
GRSetDrawMode( DC, DrawMode );
if( LibEntry->m_Prefix.m_Attributs & TEXT_NO_VISIBLE )
{
if( Color >= 0 )
color = Color;
else
color = g_InvisibleItemColor;
}
else
color = Color;
if( LibEntry->m_UnitCount > 1 )
#if defined(KICAD_GOST)
Prefix.Printf( wxT( "%s?.%c" ),
LibEntry->m_Prefix.m_Text.GetData(), Multi + '1' - 1 );
#else
Prefix.Printf( wxT( "%s?%c" ),
LibEntry->m_Prefix.m_Text.GetData(), Multi + 'A' - 1 );
#endif
else
Prefix = LibEntry->m_Prefix.m_Text + wxT( "?" );
if( (LibEntry->m_Prefix.m_Flags & IS_MOVED) == 0 )
LibEntry->m_Prefix.Draw( panel, DC, aOffset, color, DrawMode,
&Prefix, DefaultTransformMatrix );
if( LibEntry->m_Name.m_Attributs & TEXT_NO_VISIBLE )
{
if( Color >= 0 )
color = Color;
else
color = g_InvisibleItemColor;
}
else
color = Color;
if( (LibEntry->m_Name.m_Flags & IS_MOVED) == 0 )
LibEntry->m_Name.Draw( panel, DC, aOffset, color, DrawMode, NULL,
DefaultTransformMatrix );
for( Field = LibEntry->m_Fields; Field != NULL; Field = Field->Next() )
{
if( Field->m_Text.IsEmpty() )
return;
if( (Field->m_Flags & IS_MOVED) != 0 )
continue;
if( Field->m_Attributs & TEXT_NO_VISIBLE )
{
if( Color >= 0 )
color = Color;
else
color = g_InvisibleItemColor;
}
else
color = Color;
Field->Draw( panel, DC, aOffset, color, DrawMode, NULL,
DefaultTransformMatrix );
}
// Trace de l'ancre
int len = panel->GetScreen()->Unscale( 3 );
GRLine( &panel->m_ClipBox, DC, aOffset.x, aOffset.y - len, aOffset.x,
aOffset.y + len, 0, color );
GRLine( &panel->m_ClipBox, DC, aOffset.x - len, aOffset.y, aOffset.x + len,
aOffset.y, 0, color );
/* Enable this to draw the bounding box around the component to validate
* the bounding box calculations. */
#if 0
EDA_Rect bBox = LibEntry->GetBoundaryBox( Multi, convert );
GRRect( &panel->m_ClipBox, DC, bBox.GetOrigin().x, bBox.GetOrigin().y,
bBox.GetEnd().x, bBox.GetEnd().y, 0, LIGHTMAGENTA );
#endif
}
/*****************************************************************************/
/*
* Routine to find a part in one of the libraries given its name.
@ -282,53 +169,3 @@ void DrawingLibInGhost( WinEDA_DrawPanel* panel, wxDC* DC,
DrawLibItem->m_Transform, multi, convert, DrawMode, Color,
DrawPinText );
}
/************************************************************/
/* Routine to draw One LibraryDrawStruct at given position, */
/* matrice de transformation 1 0 0 -1 (normale) */
/* DrawMode = GrXOR, GrOR .. */
/************************************************************/
/* Utilise en LibEdit et Lib Browse */
void DrawLibraryDrawStruct( WinEDA_DrawPanel* aPanel, wxDC* aDC,
EDA_LibComponentStruct* aLibEntry,
wxPoint aPosition, LibEDA_BaseStruct* aDrawItem,
int aDrawMode, int aColor )
{
int TransMat[2][2];
bool no_fill;
BASE_SCREEN* screen = aPanel->GetScreen();
GRSetDrawMode( aDC, aDrawMode );
TransMat[0][0] = 1;
TransMat[0][1] = TransMat[1][0] = 0;
TransMat[1][1] = -1;
no_fill = false;
switch( aDrawItem->Type() )
{
case COMPONENT_PIN_DRAW_TYPE: /* Trace des Pins */
{
DrawPinPrms prms( aLibEntry, true );
aDrawItem->Draw( aPanel, aDC, aPosition, aColor, aDrawMode, &prms,
TransMat );
}
break;
case COMPONENT_ARC_DRAW_TYPE:
case COMPONENT_CIRCLE_DRAW_TYPE:
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
case COMPONENT_RECT_DRAW_TYPE:
case COMPONENT_POLYLINE_DRAW_TYPE:
default:
if( screen->m_IsPrinting
&& aDrawItem->m_Fill == FILLED_WITH_BG_BODYCOLOR
&& GetGRForceBlackPenState() )
no_fill = true;
aDrawItem->Draw( aPanel, aDC, aPosition, aColor, aDrawMode,
(void*) no_fill, TransMat );
break;
}
}

3
eeschema/eeschema.cpp
View File

@ -70,10 +70,11 @@ DrawSheetStruct* g_RootSheet = NULL;
SCH_SCREEN* g_ScreenLib = NULL;
wxString g_NetCmpExtBuffer( wxT( "cmp" ) );
wxString g_SymbolExtBuffer( wxT( "sym" ) );
const wxString SymbolFileExtension( wxT( "sym" ) );
const wxString CompLibFileExtension( wxT( "lib" ) );
const wxString SymbolFileWildcard( wxT( "Kicad drawing symbol file (*.sym)|*.sym" ) );
const wxString CompLibFileWildcard( wxT( "Kicad component library file (*.lib)|*.lib" ) );
wxString g_SimulatorCommandLine; // ligne de commande pour l'appel au simulateur (gnucap, spice..)

4
eeschema/general.h
View File

@ -173,7 +173,9 @@ extern SCH_SCREEN* g_ScreenLib;
/* Gestion des librairies schematiques */
extern wxString g_NetCmpExtBuffer;
extern wxString g_SymbolExtBuffer;
extern const wxString SymbolFileExtension;
extern const wxString SymbolFileWildcard;
extern const wxString CompLibFileExtension;
extern const wxString CompLibFileWildcard;

4
eeschema/libedit.cpp
View File

@ -237,8 +237,8 @@ void WinEDA_LibeditFrame::RedrawActiveWindow( wxDC* DC, bool EraseBg )
DrawPanel->DrawBackGround( DC );
if( CurrentLibEntry )
DrawLibEntry( DrawPanel, DC, CurrentLibEntry, wxPoint( 0, 0 ),
CurrentUnit, CurrentConvert, GR_DEFAULT_DRAWMODE );
CurrentLibEntry->Draw( DrawPanel, DC, wxPoint( 0, 0 ), CurrentUnit,
CurrentConvert, GR_DEFAULT_DRAWMODE );
DrawPanel->CursorOn( DC ); // redraw cursor

104
eeschema/libedit_onleftclick.cpp
View File

@ -1,5 +1,5 @@
/*****************************************/
/* EESchema - libedit_onleftclick.cpp */
/* EESchema - libedit_onleftclick.cpp */
/*****************************************/
/* Library editor commands created by a mouse left button simple or double click
@ -15,15 +15,12 @@
#include "libcmp.h"
#include "general.h"
#include "bitmaps.h"
#include "protos.h"
#include "id.h"
/************************************************************************/
void WinEDA_LibeditFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos )
/************************************************************************/
{
LibEDA_BaseStruct* DrawEntry = CurrentDrawItem;
@ -54,23 +51,27 @@ void WinEDA_LibeditFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos )
}
else
{
DrawEntry = LocatePin( GetScreen()->m_MousePosition, CurrentLibEntry,
DrawEntry = LocatePin( GetScreen()->m_MousePosition, CurrentLibEntry,
CurrentUnit, CurrentConvert );
if( DrawEntry == NULL )
{
DrawEntry = LocateDrawItem( (SCH_SCREEN*)GetScreen(), GetScreen()->m_MousePosition,
DrawEntry = LocateDrawItem( (SCH_SCREEN*)GetScreen(),
GetScreen()->m_MousePosition,
CurrentLibEntry, CurrentUnit,
CurrentConvert, LOCATE_ALL_DRAW_ITEM );
CurrentConvert,
LOCATE_ALL_DRAW_ITEM );
}
if( DrawEntry == NULL )
DrawEntry = LocatePin( GetScreen()->m_Curseur, CurrentLibEntry,
DrawEntry = LocatePin( GetScreen()->m_Curseur, CurrentLibEntry,
CurrentUnit, CurrentConvert );
if( DrawEntry == NULL )
{
DrawEntry = LocateDrawItem( (SCH_SCREEN*)GetScreen(), GetScreen()->m_Curseur,
DrawEntry = LocateDrawItem( (SCH_SCREEN*)GetScreen(),
GetScreen()->m_Curseur,
CurrentLibEntry, CurrentUnit,
CurrentConvert, LOCATE_ALL_DRAW_ITEM );
CurrentConvert,
LOCATE_ALL_DRAW_ITEM );
}
if( DrawEntry )
@ -80,7 +81,7 @@ void WinEDA_LibeditFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos )
{
EraseMsgBox();
AfficheDoc( this, CurrentLibEntry->m_Doc.GetData(),
CurrentLibEntry->m_KeyWord.GetData() );
CurrentLibEntry->m_KeyWord.GetData() );
}
}
}
@ -126,39 +127,41 @@ void WinEDA_LibeditFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos )
break;
case ID_LIBEDIT_DELETE_ITEM_BUTT:
DrawEntry = LocatePin( GetScreen()->m_MousePosition, CurrentLibEntry,
DrawEntry = LocatePin( GetScreen()->m_MousePosition, CurrentLibEntry,
CurrentUnit, CurrentConvert );
if( DrawEntry == NULL )
{
DrawEntry = LocateDrawItem( (SCH_SCREEN*)GetScreen(),
GetScreen()->m_MousePosition,
DrawEntry = LocateDrawItem( (SCH_SCREEN*)GetScreen(),
GetScreen()->m_MousePosition,
CurrentLibEntry, CurrentUnit,
CurrentConvert, LOCATE_ALL_DRAW_ITEM );
CurrentConvert,
LOCATE_ALL_DRAW_ITEM );
}
if( DrawEntry == NULL )
DrawEntry = LocatePin( GetScreen()->m_Curseur, CurrentLibEntry,
DrawEntry = LocatePin( GetScreen()->m_Curseur, CurrentLibEntry,
CurrentUnit, CurrentConvert );
if( DrawEntry == NULL )
{
DrawEntry = LocateDrawItem( (SCH_SCREEN*)GetScreen(),
GetScreen()->m_Curseur,
DrawEntry = LocateDrawItem( (SCH_SCREEN*)GetScreen(),
GetScreen()->m_Curseur,
CurrentLibEntry, CurrentUnit,
CurrentConvert, LOCATE_ALL_DRAW_ITEM );
CurrentConvert,
LOCATE_ALL_DRAW_ITEM );
}
if( DrawEntry == NULL )
{
AfficheDoc( this, CurrentLibEntry->m_Doc.GetData(),
CurrentLibEntry->m_KeyWord.GetData() );
CurrentLibEntry->m_KeyWord.GetData() );
break;
}
SaveCopyInUndoList( CurrentLibEntry );
if( DrawEntry->Type() == COMPONENT_PIN_DRAW_TYPE )
DeletePin( DC, CurrentLibEntry, (LibDrawPin*) DrawEntry );
else
DeleteOneLibraryDrawStruct( DrawPanel, DC, CurrentLibEntry, DrawEntry, TRUE );
CurrentLibEntry->RemoveDrawItem( DrawEntry, DrawPanel, DC );
DrawEntry = NULL;
GetScreen()->SetModify();
GetScreen()->SetModify();
break;
case ID_LIBEDIT_ANCHOR_ITEM_BUTT:
@ -169,7 +172,8 @@ void WinEDA_LibeditFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos )
default:
DisplayError( this, wxT( "WinEDA_LibeditFrame::OnLeftClick error" ) );
DisplayError( this,
wxT( "WinEDA_LibeditFrame::OnLeftClick error" ) );
SetToolID( 0, wxCURSOR_ARROW, wxEmptyString );
break;
}
@ -177,14 +181,12 @@ void WinEDA_LibeditFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos )
}
/*************************************************************************/
void WinEDA_LibeditFrame::OnLeftDClick( wxDC* DC, const wxPoint& MousePos )
/*************************************************************************/
/* Called on a double click:
/*
* Called on a double click:
* If an editable item (field, pin, graphic):
* Call the suitable dialog editor.
*/
void WinEDA_LibeditFrame::OnLeftDClick( wxDC* DC, const wxPoint& MousePos )
{
wxPoint pos = GetPosition();
LibEDA_BaseStruct* DrawEntry = CurrentDrawItem;
@ -192,33 +194,33 @@ void WinEDA_LibeditFrame::OnLeftDClick( wxDC* DC, const wxPoint& MousePos )
if( CurrentLibEntry == NULL )
return;
if( (DrawEntry == NULL) || (DrawEntry->m_Flags == 0) )
if( ( DrawEntry == NULL ) || ( DrawEntry->m_Flags == 0 ) )
{ // We can locate an item
DrawEntry = LocatePin( GetScreen()->m_MousePosition, CurrentLibEntry,
DrawEntry = LocatePin( GetScreen()->m_MousePosition, CurrentLibEntry,
CurrentUnit, CurrentConvert );
if( DrawEntry == NULL )
DrawEntry = LocatePin( GetScreen()->m_Curseur, CurrentLibEntry,
DrawEntry = LocatePin( GetScreen()->m_Curseur, CurrentLibEntry,
CurrentUnit, CurrentConvert );
if( DrawEntry == NULL )
{
DrawEntry = CurrentDrawItem = LocateDrawItem( (SCH_SCREEN*) GetScreen(),
GetScreen()->m_MousePosition,
CurrentLibEntry, CurrentUnit,
CurrentConvert,
LOCATE_ALL_DRAW_ITEM );
DrawEntry = CurrentDrawItem =
LocateDrawItem( (SCH_SCREEN*) GetScreen(),
GetScreen()->m_MousePosition,
CurrentLibEntry, CurrentUnit,
CurrentConvert, LOCATE_ALL_DRAW_ITEM );
}
if( DrawEntry == NULL )
{
DrawEntry = CurrentDrawItem = LocateDrawItem( (SCH_SCREEN*) GetScreen(),
GetScreen()->m_Curseur,
CurrentLibEntry, CurrentUnit,
CurrentConvert,
LOCATE_ALL_DRAW_ITEM );
DrawEntry = CurrentDrawItem =
LocateDrawItem( (SCH_SCREEN*) GetScreen(),
GetScreen()->m_Curseur,
CurrentLibEntry, CurrentUnit,
CurrentConvert, LOCATE_ALL_DRAW_ITEM );
}
if( DrawEntry == NULL )
{
DrawEntry = CurrentDrawItem = (LibEDA_BaseStruct*)
LocateField( CurrentLibEntry );
DrawEntry = CurrentDrawItem =
(LibEDA_BaseStruct*) LocateField( CurrentLibEntry );
}
if( DrawEntry == NULL )
{
@ -226,14 +228,6 @@ void WinEDA_LibeditFrame::OnLeftDClick( wxDC* DC, const wxPoint& MousePos )
}
}
// Si Commande en cours: affichage commande d'annulation
if( m_ID_current_state )
{
}
else
{
}
if( DrawEntry )
DrawEntry->DisplayInfo( this );
else
@ -246,7 +240,7 @@ void WinEDA_LibeditFrame::OnLeftDClick( wxDC* DC, const wxPoint& MousePos )
switch( DrawEntry->Type() )
{
case COMPONENT_PIN_DRAW_TYPE:
if( DrawEntry->m_Flags == 0 ) // Item localis<69> et non en edition: placement commande move
if( DrawEntry->m_Flags == 0 )
{
InstallPineditFrame( this, DC, pos );
}
@ -290,9 +284,9 @@ void WinEDA_LibeditFrame::OnLeftDClick( wxDC* DC, const wxPoint& MousePos )
default:
wxString msg;
msg.Printf(
wxT( "WinEDA_LibeditFrame::OnLeftDClick Error: unknown StructType %d" ),
DrawEntry->Type() );
msg.Printf( wxT( "WinEDA_LibeditFrame::OnLeftDClick Error: unknown \
StructType %d" ),
DrawEntry->Type() );
DisplayError( this, msg );
break;
}

268
eeschema/libfield.cpp
View File

@ -1,14 +1,11 @@
/*********************************************************************/
/* EESchema - edition des librairies: Edition des champs ( Fields ) */
/* EESchema - edition des librairies: Edition des champs ( Fields ) */
/*********************************************************************/
/* Fichier libfield.cpp */
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "class_drawpanel.h"
#include "drawtxt.h"
#include "confirm.h"
#include "program.h"
@ -17,33 +14,31 @@
#include "protos.h"
#include "wx/spinctrl.h"
/* Routines locales */
static void ShowMoveField( WinEDA_DrawPanel* panel, wxDC* DC, bool erase );
static void ShowMoveField( WinEDA_DrawPanel* panel, wxDC* DC, bool erase );
/* if the field is the reference, return reference like schematic, i.e U -> U? or U?A
* or the field text for others
/*
* if the field is the reference, return reference like schematic,
* i.e U -> U? or U?A or the field text for others
*/
static wxString ReturnFieldFullText( LibDrawField* aField );
/* Variables locales */
/* Variables locales */
extern int CurrentUnit;
static wxPoint StartCursor, LastTextPosition;
/***********************************************************/
static void ExitMoveField( WinEDA_DrawPanel* Panel, wxDC* DC )
/***********************************************************/
{
Panel->ManageCurseur = NULL;
Panel->ForceCloseManageCurseur = NULL;
if( CurrentDrawItem == NULL )
return;
wxPoint curpos;
curpos = Panel->GetScreen()->m_Curseur;
wxPoint curpos = Panel->GetScreen()->m_Curseur;
Panel->GetScreen()->m_Curseur = StartCursor;
ShowMoveField( Panel, DC, TRUE );
Panel->GetScreen()->m_Curseur = curpos;
@ -53,15 +48,16 @@ static void ExitMoveField( WinEDA_DrawPanel* Panel, wxDC* DC )
}
/****************************************************************************/
/*
* Initialise le deplacement d'un champ ( ref ou Name )
*/
void WinEDA_LibeditFrame::StartMoveField( wxDC* DC, LibDrawField* field )
/****************************************************************************/
/* Initialise le deplacement d'un champ ( ref ou Name) */
{
wxPoint startPos;
if( (CurrentLibEntry == NULL) || ( field == NULL ) )
if( ( CurrentLibEntry == NULL ) || ( field == NULL ) )
return;
CurrentDrawItem = field;
LastTextPosition = field->m_Pos;
CurrentDrawItem->m_Flags |= IS_MOVED;
@ -81,8 +77,11 @@ void WinEDA_LibeditFrame::StartMoveField( wxDC* DC, LibDrawField* field )
}
/* if the field is the reference, return reference like schematic, i.e U -> U? or U?A
* or the field text for others
/*
* If the field is the reference, return reference like schematic,
* i.e U -> U? or U?A or the field text for others
*
* @fixme This should be handled by the field object.
*/
static wxString ReturnFieldFullText( LibDrawField* aField )
{
@ -111,101 +110,46 @@ static wxString ReturnFieldFullText( LibDrawField* aField )
/*****************************************************************/
/* Routine d'affichage du texte 'Field' en cours de deplacement. */
/* Routine normalement attachee au curseur */
/* Routine normalement attachee au curseur */
/*****************************************************************/
static void ShowMoveField( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
{
int color;
LibDrawField* Field = (LibDrawField*) CurrentDrawItem;
if( (CurrentLibEntry == NULL) || (Field == NULL) )
if( ( CurrentLibEntry == NULL ) || ( Field == NULL ) )
return;
switch( Field->m_FieldId )
{
case VALUE:
color = ReturnLayerColor( LAYER_VALUEPART );
break;
case REFERENCE:
color = ReturnLayerColor( LAYER_REFERENCEPART );
break;
default:
color = ReturnLayerColor( LAYER_FIELDS );
break;
}
wxString text = ReturnFieldFullText( Field );
int TransMat[2][2];
TransMat[0][0] = 1; TransMat[1][1] = -1;
TransMat[1][0] = TransMat[0][1] = 0;
if( Field->m_Attributs & TEXT_NO_VISIBLE )
color = DARKGRAY;
if( erase )
Field->Draw( panel, DC, wxPoint( 0, 0 ),
color,
g_XorMode, &text, TransMat );
Field->Draw( panel, DC, wxPoint( 0, 0 ), -1, g_XorMode, &text,
DefaultTransformMatrix );
LastTextPosition.x = panel->GetScreen()->m_Curseur.x;
LastTextPosition.y = -panel->GetScreen()->m_Curseur.y;
Field->m_Pos = LastTextPosition;
Field->Draw( panel, DC, wxPoint( 0, 0 ),
color,
g_XorMode, &text, TransMat );
Field->Draw( panel, DC, wxPoint( 0, 0 ), -1, g_XorMode, &text,
DefaultTransformMatrix );
}
/*******************************************************************/
void WinEDA_LibeditFrame::PlaceField( wxDC* DC, LibDrawField* Field )
/*******************************************************************/
{
EDA_Colors color;
if( Field == NULL )
return;
switch( Field->m_FieldId )
{
case REFERENCE:
color = ReturnLayerColor( LAYER_REFERENCEPART );
break;
case VALUE:
color = ReturnLayerColor( LAYER_VALUEPART );
break;
default:
color = ReturnLayerColor( LAYER_FIELDS );
break;
}
Field->m_Flags = 0;
if( (Field->m_Attributs & TEXT_NO_VISIBLE) != 0 )
color = DARKGRAY;
Field->m_Pos.x = GetScreen()->m_Curseur.x;
Field->m_Pos.y = -GetScreen()->m_Curseur.y;
int linewidth = (Field->m_Width == 0) ? g_DrawDefaultLineThickness : Field->m_Width;
linewidth = Clamp_Text_PenSize( linewidth, Field->m_Size, Field->m_Bold );
DrawPanel->CursorOff( DC );
GRSetDrawMode( DC, GR_DEFAULT_DRAWMODE );
DrawGraphicText( DrawPanel, DC, wxPoint( Field->m_Pos.x, -Field->m_Pos.y ),
color, ReturnFieldFullText( Field ),
Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
Field->m_HJustify, Field->m_VJustify, linewidth,
Field->m_Italic, Field->m_Bold);
wxString fieldText = ReturnFieldFullText( Field );
Field->Draw( DrawPanel, DC, wxPoint( 0, 0 ), -1, GR_DEFAULT_DRAWMODE,
&fieldText, DefaultTransformMatrix );
DrawPanel->CursorOn( DC );
GetScreen()->SetModify();
DrawPanel->ManageCurseur = NULL;
DrawPanel->ForceCloseManageCurseur = NULL;
@ -213,15 +157,10 @@ void WinEDA_LibeditFrame::PlaceField( wxDC* DC, LibDrawField* Field )
}
/******************************************************************/
void WinEDA_LibeditFrame::EditField( wxDC* DC, LibDrawField* Field )
/******************************************************************/
{
wxString Text;
wxString title;
EDA_Colors color;
int linewidth = (Field->m_Width == 0) ? g_DrawDefaultLineThickness : Field->m_Width;
linewidth = Clamp_Text_PenSize( linewidth, Field->m_Size, Field->m_Bold );
if( Field == NULL )
return;
@ -230,53 +169,49 @@ void WinEDA_LibeditFrame::EditField( wxDC* DC, LibDrawField* Field )
{
case REFERENCE:
title = wxT( "Reference:" );
color = ReturnLayerColor( LAYER_REFERENCEPART );
break;
case VALUE:
title = wxT( "Component Name / Value:" );
color = ReturnLayerColor( LAYER_VALUEPART );
break;
default:
color = ReturnLayerColor( LAYER_FIELDS );
break;
}
if( Field->m_Attributs & TEXT_NO_VISIBLE )
color = DARKGRAY;
Text = Field->m_Text;
/* FIXME: Use wxTextEntry dialog here and check for cancel button. */
Get_Message( title, _( "Edit field" ), Text, this );
Text.Replace( wxT( " " ), wxT( "_" ) );
/* If the value is changed, this is equivalent to create a new component from the old one
/* If the value is changed, this is equivalent to create a new component
* from the old one.
* So we must check for an existing alias of this "new" component
* and change the value only if there is no existing alias with the same name
* for this component
* and change the value only if there is no existing alias with the same
* name for this component
*/
if( Field->m_FieldId == VALUE )
{
/* test for an existing name in alias list: */
for( unsigned ii = 0; ii < CurrentLibEntry->m_AliasList.GetCount(); ii += ALIAS_NEXT )
for( unsigned ii = 0; ii < CurrentLibEntry->m_AliasList.GetCount();
ii += ALIAS_NEXT )
{
wxString aliasname = CurrentLibEntry->m_AliasList[ii + ALIAS_NAME];
if( Text.CmpNoCase( aliasname ) == 0 )
{
DisplayError( this,
_( "This name is an existing alias of the component\nAborting" ), 10 );
DisplayError( this, _( "This name is an existing alias of \
the component\nAborting" ) );
return;
}
}
}
GRSetDrawMode( DC, g_XorMode );
DrawGraphicText( DrawPanel, DC, wxPoint( Field->m_Pos.x, -Field->m_Pos.y ),
color, ReturnFieldFullText( Field ),
Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
Field->m_HJustify, Field->m_VJustify, linewidth,
Field->m_Italic, Field->m_Bold);
wxString fieldText = ReturnFieldFullText( Field );
Field->Draw( DrawPanel, DC, wxPoint( 0, 0 ), -1, g_XorMode, &fieldText,
DefaultTransformMatrix );
if( !Text.IsEmpty() )
{
@ -284,17 +219,18 @@ void WinEDA_LibeditFrame::EditField( wxDC* DC, LibDrawField* Field )
Field->m_Text = Text;
}
else
{
DisplayError( this, _( "No new text: no change" ) );
}
fieldText = ReturnFieldFullText( Field );
int drawMode = g_XorMode;
if( Field->m_Flags == 0 )
GRSetDrawMode( DC, GR_DEFAULT_DRAWMODE );
drawMode = GR_DEFAULT_DRAWMODE;
DrawGraphicText( DrawPanel, DC, wxPoint( Field->m_Pos.x, -Field->m_Pos.y ),
color, ReturnFieldFullText( Field ),
Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
Field->m_HJustify, Field->m_VJustify, linewidth,
Field->m_Italic, Field->m_Bold);
Field->Draw( DrawPanel, DC, wxPoint( 0, 0 ), -1, drawMode, &fieldText,
DefaultTransformMatrix );
GetScreen()->SetModify();
@ -303,78 +239,50 @@ void WinEDA_LibeditFrame::EditField( wxDC* DC, LibDrawField* Field )
}
/********************************************************************/
void WinEDA_LibeditFrame::RotateField( wxDC* DC, LibDrawField* Field )
/********************************************************************/
/* Routine de modification de l'orientation ( Horiz ou Vert. ) du champ.
/*
* Routine de modification de l'orientation ( Horiz ou Vert. ) du champ.
* si un champ est en cours d'edition, modif de celui ci.
* sinon Modif du champ pointe par la souris
*/
void WinEDA_LibeditFrame::RotateField( wxDC* DC, LibDrawField* Field )
{
EDA_Colors color;
if( Field == NULL )
return;
GetScreen()->SetModify();
switch( Field->m_FieldId )
{
case REFERENCE:
color = ReturnLayerColor( LAYER_REFERENCEPART );
break;
case VALUE:
color = ReturnLayerColor( LAYER_VALUEPART );
break;
default:
color = ReturnLayerColor( LAYER_FIELDS );
break;
}
if( (Field->m_Attributs & TEXT_NO_VISIBLE) != 0 )
color = DARKGRAY;
DrawPanel->CursorOff( DC );
GRSetDrawMode( DC, g_XorMode );
int linewidth = (Field->m_Width == 0) ? g_DrawDefaultLineThickness : Field->m_Width;
linewidth = Clamp_Text_PenSize( linewidth, Field->m_Size, Field->m_Bold );
DrawGraphicText( DrawPanel, DC, wxPoint( Field->m_Pos.x, -Field->m_Pos.y ),
color, ReturnFieldFullText( Field ),
Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
Field->m_HJustify, Field->m_VJustify, linewidth,
Field->m_Italic, Field->m_Bold);
wxString fieldText = ReturnFieldFullText( Field );
Field->Draw( DrawPanel, DC, wxPoint( 0, 0 ), -1, g_XorMode, &fieldText,
DefaultTransformMatrix );
if( Field->m_Orient )
Field->m_Orient = 0;
else
Field->m_Orient = 1;
if( Field->m_Flags == 0 )
GRSetDrawMode( DC, GR_DEFAULT_DRAWMODE );
int drawMode = g_XorMode;
if( Field->m_Flags == 0 )
drawMode = GR_DEFAULT_DRAWMODE;
Field->Draw( DrawPanel, DC, wxPoint( 0, 0 ), -1, drawMode, &fieldText,
DefaultTransformMatrix );
DrawGraphicText( DrawPanel, DC, wxPoint( Field->m_Pos.x, -Field->m_Pos.y ),
color, ReturnFieldFullText( Field ),
Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
Field->m_HJustify, Field->m_VJustify, linewidth,
Field->m_Italic, Field->m_Bold);
DrawPanel->CursorOn( DC );
}
/****************************************************************************/
LibDrawField* WinEDA_LibeditFrame::LocateField( EDA_LibComponentStruct* LibEntry )
/****************************************************************************/
/* Locate the component fiels (ref, name or auxiliary fields) under the mouse cursor
/*
* Locate the component fiels (ref, name or auxiliary fields) under the
* mouse cursor
* return:
* pointer on the field (or NULL )
* pointer on the field (or NULL )
*/
LibDrawField* WinEDA_LibeditFrame::LocateField( EDA_LibComponentStruct* LibEntry )
{
wxPoint refpos = GetScreen()->m_Curseur;
/* Test reference */
@ -386,7 +294,8 @@ LibDrawField* WinEDA_LibeditFrame::LocateField( EDA_LibComponentStruct* LibEntry
return &LibEntry->m_Prefix;
/* Test others fields */
for( LibDrawField* field = LibEntry->m_Fields; field; field = field->Next() )
for( LibDrawField* field = LibEntry->m_Fields; field != NULL;
field = field->Next() )
{
if( field->m_Text.IsEmpty() )
continue;
@ -399,38 +308,39 @@ LibDrawField* WinEDA_LibeditFrame::LocateField( EDA_LibComponentStruct* LibEntry
}
/********************************************************************************/
LibEDA_BaseStruct* WinEDA_LibeditFrame::LocateItemUsingCursor()
/********************************************************************************/
{
LibEDA_BaseStruct* DrawEntry = CurrentDrawItem;
if( CurrentLibEntry == NULL )
return NULL;
if( (DrawEntry == NULL) || (DrawEntry->m_Flags == 0) ) // Simple localisation des elements
if( ( DrawEntry == NULL ) || ( DrawEntry->m_Flags == 0 ) )
{
DrawEntry = LocatePin(
GetScreen()->m_Curseur, CurrentLibEntry, CurrentUnit, CurrentConvert );
DrawEntry = LocatePin( GetScreen()->m_Curseur, CurrentLibEntry,
CurrentUnit, CurrentConvert );
if( DrawEntry == NULL )
{
DrawEntry = CurrentDrawItem = LocateDrawItem( (SCH_SCREEN*) GetScreen(),
GetScreen()->m_MousePosition,
CurrentLibEntry, CurrentUnit,
CurrentConvert, LOCATE_ALL_DRAW_ITEM );
DrawEntry = CurrentDrawItem =
LocateDrawItem( (SCH_SCREEN*) GetScreen(),
GetScreen()->m_MousePosition,
CurrentLibEntry, CurrentUnit,
CurrentConvert, LOCATE_ALL_DRAW_ITEM );
}
if( DrawEntry == NULL )
{
DrawEntry = CurrentDrawItem = LocateDrawItem( (SCH_SCREEN*) GetScreen(),
GetScreen()->m_Curseur, CurrentLibEntry,
CurrentUnit,
CurrentConvert, LOCATE_ALL_DRAW_ITEM );
DrawEntry = CurrentDrawItem =
LocateDrawItem( (SCH_SCREEN*) GetScreen(),
GetScreen()->m_Curseur, CurrentLibEntry,
CurrentUnit, CurrentConvert,
LOCATE_ALL_DRAW_ITEM );
}
if( DrawEntry == NULL )
{
DrawEntry = CurrentDrawItem = (LibEDA_BaseStruct*)
LocateField( CurrentLibEntry );
DrawEntry = CurrentDrawItem =
(LibEDA_BaseStruct*) LocateField( CurrentLibEntry );
}
}
return DrawEntry;
}

52
eeschema/libframe.cpp
View File

@ -118,7 +118,7 @@ WinEDA_LibeditFrame::WinEDA_LibeditFrame( wxWindow* father,
// Give an icon
SetIcon( wxIcon( libedit_xpm ) );
SetBaseScreen( g_ScreenLib );
GetScreen()->m_Center = true; // set to true to have the coordinates origine -0,0) centered on screen
GetScreen()->m_Center = true;
LoadSettings();
SetSize( m_FramePos.x, m_FramePos.y, m_FrameSize.x, m_FrameSize.y );
if( DrawPanel )
@ -181,9 +181,7 @@ void WinEDA_LibeditFrame::SaveSettings()
}
/***********************************************************/
void WinEDA_LibeditFrame::OnCloseWindow( wxCloseEvent& Event )
/***********************************************************/
{
LibraryStruct* Lib;
@ -218,13 +216,14 @@ void WinEDA_LibeditFrame::OnCloseWindow( wxCloseEvent& Event )
}
/******************************************/
void WinEDA_LibeditFrame::SetToolbars()
/******************************************/
/* Enable or disable tools of the differents toolbars,
* according to the current conditions or options
/*
* Enable or disable tools of the differents toolbars, according to the
* current conditions or options.
*
* FIXME: Get rid of this function and use WX_UPDATE_UI to handle enabling of
* menu and toolbar items.
*/
void WinEDA_LibeditFrame::SetToolbars()
{
if( m_HToolBar == NULL )
return;
@ -282,7 +281,8 @@ void WinEDA_LibeditFrame::SetToolbars()
else
m_HToolBar->EnableTool( ID_LIBEDIT_EDIT_PIN_BY_PIN, false );
m_HToolBar->ToggleTool( ID_LIBEDIT_EDIT_PIN_BY_PIN, g_EditPinByPinIsOn );
m_HToolBar->ToggleTool( ID_LIBEDIT_EDIT_PIN_BY_PIN,
g_EditPinByPinIsOn );
m_HToolBar->EnableTool( ID_DE_MORGAN_CONVERT_BUTT, g_AsDeMorgan );
m_HToolBar->EnableTool( ID_DE_MORGAN_NORMAL_BUTT, g_AsDeMorgan );
@ -290,7 +290,8 @@ void WinEDA_LibeditFrame::SetToolbars()
bool enable_dtool = false;
if( !CurrentAliasName.IsEmpty() )
{
int AliasLocation = LocateAlias( CurrentLibEntry->m_AliasList, CurrentAliasName );
int AliasLocation = LocateAlias( CurrentLibEntry->m_AliasList,
CurrentAliasName );
if( AliasLocation >= 0 )
if( !CurrentLibEntry->m_AliasList[AliasLocation +
ALIAS_DOC_FILENAME].IsEmpty() )
@ -307,8 +308,10 @@ void WinEDA_LibeditFrame::SetToolbars()
if( GetScreen() )
{
m_HToolBar->EnableTool( ID_LIBEDIT_UNDO, GetScreen()->GetUndoCommandCount() );
m_HToolBar->EnableTool( ID_LIBEDIT_REDO, GetScreen()->GetRedoCommandCount() );
m_HToolBar->EnableTool( ID_LIBEDIT_UNDO,
GetScreen()->GetUndoCommandCount() );
m_HToolBar->EnableTool( ID_LIBEDIT_REDO,
GetScreen()->GetRedoCommandCount() );
}
}
@ -330,9 +333,7 @@ void WinEDA_LibeditFrame::SetToolbars()
}
/**************************************/
int WinEDA_LibeditFrame::BestZoom()
/**************************************/
{
int dx, dy, ii, jj;
int bestzoom;
@ -341,7 +342,8 @@ int WinEDA_LibeditFrame::BestZoom()
if( CurrentLibEntry )
{
BoundaryBox = CurrentLibEntry->GetBoundaryBox( CurrentUnit, CurrentConvert );
BoundaryBox = CurrentLibEntry->GetBoundaryBox( CurrentUnit,
CurrentConvert );
dx = BoundaryBox.GetWidth();
dy = BoundaryBox.GetHeight();
}
@ -383,9 +385,7 @@ void WinEDA_LibeditFrame::OnUpdateNotEditingPart( wxUpdateUIEvent& event )
}
/*************************************************************************/
void WinEDA_LibeditFrame::Process_Special_Functions( wxCommandEvent& event )
/*************************************************************************/
{
int id = event.GetId();
wxPoint pos;
@ -514,15 +514,18 @@ void WinEDA_LibeditFrame::Process_Special_Functions( wxCommandEvent& event )
wxString docfilename;
if( !CurrentAliasName.IsEmpty() )
{
int AliasLocation = LocateAlias( CurrentLibEntry->m_AliasList, CurrentAliasName );
int AliasLocation = LocateAlias( CurrentLibEntry->m_AliasList,
CurrentAliasName );
if( AliasLocation >= 0 )
docfilename = CurrentLibEntry->m_AliasList[AliasLocation + ALIAS_DOC_FILENAME];
docfilename =
CurrentLibEntry->m_AliasList[AliasLocation + ALIAS_DOC_FILENAME];
}
else
docfilename = CurrentLibEntry->m_DocFile;
if( !docfilename.IsEmpty() )
GetAssociatedDocument( this, docfilename, & wxGetApp().GetLibraryPathList() );
GetAssociatedDocument( this, docfilename,
&wxGetApp().GetLibraryPathList() );
}
break;
@ -667,7 +670,6 @@ void WinEDA_LibeditFrame::Process_Special_Functions( wxCommandEvent& event )
case ID_POPUP_LIBEDIT_DELETE_CURRENT_POLY_SEGMENT:
// Delete the last created segment, while creating a polyline draw item
if( CurrentDrawItem == NULL )
break;
@ -690,7 +692,8 @@ void WinEDA_LibeditFrame::Process_Special_Functions( wxCommandEvent& event )
if( DrawPanel->ManageCurseur && DrawPanel->ForceCloseManageCurseur )
DrawPanel->ForceCloseManageCurseur( DrawPanel, &dc );
else
DeleteOneLibraryDrawStruct( DrawPanel, &dc, CurrentLibEntry, CurrentDrawItem, true );
CurrentLibEntry->RemoveDrawItem( CurrentDrawItem, DrawPanel,
&dc );
}
CurrentDrawItem = NULL;
@ -798,7 +801,8 @@ void WinEDA_LibeditFrame::Process_Special_Functions( wxCommandEvent& event )
break;
default:
DisplayError( this, wxT( "WinEDA_LibeditFrame::Process_Special_Functions error" ) );
DisplayError( this,
wxT( "WinEDA_LibeditFrame::Process_Special_Functions error" ) );
break;
}

29
eeschema/pinedit-dialog.cpp
View File

@ -20,24 +20,29 @@
////@begin XPM images
////@end XPM images
/*****************************************************************************************/
void InstallPineditFrame(WinEDA_LibeditFrame * parent, wxDC * DC, const wxPoint & pos)
/*****************************************************************************************/
void InstallPineditFrame( WinEDA_LibeditFrame* parent, wxDC* DC,
const wxPoint & pos )
{
wxPoint MousePos = parent->GetScreen()->m_Curseur;
int accept = TRUE;
if ( (CurrentDrawItem == NULL) || (CurrentDrawItem->Type() == COMPONENT_PIN_DRAW_TYPE) )
wxPoint MousePos = parent->GetScreen()->m_Curseur;
int accept = TRUE;
if ( ( CurrentDrawItem == NULL )
|| ( CurrentDrawItem->Type() == COMPONENT_PIN_DRAW_TYPE ) )
{
LibDrawPin * Pin = (LibDrawPin *) CurrentDrawItem;
WinEDA_PinPropertiesFrame * frame = new WinEDA_PinPropertiesFrame(parent);
accept = frame->ShowModal(); frame->Destroy();
if ( !accept && Pin && ( Pin->m_Flags & IS_NEW ) ) // Abord create new pin
WinEDA_PinPropertiesFrame dlg( parent );
accept = dlg.ShowModal();
if ( !accept && Pin && ( Pin->m_Flags & IS_NEW ) )
{
if ( parent->DrawPanel->ForceCloseManageCurseur && DC)
parent->DrawPanel->ForceCloseManageCurseur(parent->DrawPanel, DC);
if ( parent->DrawPanel->ForceCloseManageCurseur && DC )
parent->DrawPanel->ForceCloseManageCurseur( parent->DrawPanel,
DC );
}
}
else DisplayError(parent, wxT("Error: Not a Pin!") );
else
DisplayError( parent, wxT( "Error: Not a Pin!" ) );
parent->GetScreen()->m_Curseur = MousePos;
parent->DrawPanel->MouseToCursorSchema();
}

64
eeschema/pinedit.cpp
View File

@ -25,7 +25,8 @@ static wxString shape_list[NBSHAPES] =
int CodeShape[NBSHAPES] =
{
NONE, INVERT, CLOCK, CLOCK | INVERT, LOWLEVEL_IN, LOWLEVEL_IN | CLOCK, LOWLEVEL_OUT
NONE, INVERT, CLOCK, CLOCK | INVERT, LOWLEVEL_IN, LOWLEVEL_IN | CLOCK,
LOWLEVEL_OUT
};
@ -38,9 +39,9 @@ static void DrawMovePin( WinEDA_DrawPanel* panel, wxDC* DC, bool erase );
/* Variables locales */
static wxPoint OldPos, PinPreviousPos;
static int LastPinType = PIN_INPUT,
LastPinOrient = PIN_RIGHT,
LastPinShape = NONE,
static int LastPinType = PIN_INPUT,
LastPinOrient = PIN_RIGHT,
LastPinShape = NONE,
LastPinSize = 300,
LastPinNameSize = 50,
LastPinNumSize = 50,
@ -97,7 +98,6 @@ void WinEDA_PinPropertiesFrame::PinPropertiesAccept( wxCommandEvent& event )
CurrentDrawItem->DisplayInfo( m_Parent );
}
Close();
m_Parent->DrawPanel->Refresh();
}
@ -154,8 +154,7 @@ static void AbortPinMove( WinEDA_DrawPanel* Panel, wxDC* DC )
LibDrawPin* CurrentPin = (LibDrawPin*) CurrentDrawItem;
if( CurrentPin && ( CurrentPin->m_Flags & IS_NEW ) )
DeleteOneLibraryDrawStruct( Panel, DC, CurrentLibEntry,
CurrentPin, true );
CurrentLibEntry->RemoveDrawItem( CurrentPin, Panel, DC );
/* clear edit flags */
LibEDA_BaseStruct* item = CurrentLibEntry->m_Drawings;
@ -240,8 +239,9 @@ void WinEDA_LibeditFrame::PlacePin( wxDC* DC )
}
DrawPanel->CursorOff( DC );
DrawLibraryDrawStruct( DrawPanel, DC, CurrentLibEntry, wxPoint( 0, 0 ),
CurrentPin, GR_DEFAULT_DRAWMODE );
bool showPinText = true;
CurrentPin->Draw( DrawPanel, DC, wxPoint( 0, 0 ), -1, GR_DEFAULT_DRAWMODE,
&showPinText, DefaultTransformMatrix );
DrawPanel->CursorOn( DC );
CurrentDrawItem = NULL;
@ -330,20 +330,21 @@ static void DrawMovePin( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
{
LibDrawPin* CurrentPin = (LibDrawPin*) CurrentDrawItem;
wxPoint pinpos = CurrentPin->m_Pos;
bool showPinText = true;
/* Erase pin in old position */
if( erase || ( CurrentPin->m_Flags & IS_NEW ) )
{
CurrentPin->m_Pos = PinPreviousPos;
DrawLibraryDrawStruct( panel, DC, CurrentLibEntry, wxPoint(0, 0),
CurrentPin, g_XorMode );
CurrentPin->Draw( panel, DC, wxPoint( 0, 0 ), -1, g_XorMode,
&showPinText, DefaultTransformMatrix );
}
/* Redraw pin in new position */
CurrentPin->m_Pos.x = panel->GetScreen()->m_Curseur.x;
CurrentPin->m_Pos.y = -panel->GetScreen()->m_Curseur.y;
DrawLibraryDrawStruct( panel, DC, CurrentLibEntry, wxPoint( 0, 0 ),
CurrentPin, g_XorMode );
CurrentPin->Draw( panel, DC, wxPoint( 0, 0 ), -1, g_XorMode,
&showPinText, DefaultTransformMatrix );
PinPreviousPos = CurrentPin->m_Pos;
@ -514,13 +515,11 @@ void WinEDA_LibeditFrame::DeletePin( wxDC* DC,
LibEDA_BaseStruct* DrawItem;
wxPoint PinPos;
if( LibEntry == NULL )
return;
if( Pin == NULL )
if( LibEntry == NULL || Pin == NULL )
return;
PinPos = Pin->m_Pos;
DeleteOneLibraryDrawStruct( DrawPanel, DC, LibEntry, Pin, true );
LibEntry->RemoveDrawItem( (LibEDA_BaseStruct*) Pin, DrawPanel, DC );
/* Effacement des autres pins de meme coordonnees */
if( g_EditPinByPinIsOn == false )
@ -537,7 +536,7 @@ void WinEDA_LibeditFrame::DeletePin( wxDC* DC,
DrawItem = DrawItem->Next();
if( Pin->m_Pos != PinPos )
continue;
DeleteOneLibraryDrawStruct( DrawPanel, DC, LibEntry, Pin, 0 );
LibEntry->RemoveDrawItem( (LibEDA_BaseStruct*) Pin );
}
}
GetScreen()->SetModify();
@ -551,6 +550,7 @@ void WinEDA_LibeditFrame::CreatePin( wxDC* DC )
{
LibEDA_BaseStruct* DrawItem;
LibDrawPin* CurrentPin;
bool showPinText = true;
if( CurrentLibEntry == NULL )
return;
@ -599,8 +599,8 @@ void WinEDA_LibeditFrame::CreatePin( wxDC* DC )
CurrentLibEntry->SortDrawItems();
if( DC )
DrawLibraryDrawStruct( DrawPanel, DC, CurrentLibEntry,
wxPoint(0, 0), CurrentPin, g_XorMode );
CurrentPin->Draw( DrawPanel, DC, wxPoint( 0, 0 ), -1, g_XorMode,
&showPinText, DefaultTransformMatrix );
DrawPanel->m_IgnoreMouseEvents = true;
InstallPineditFrame( this, DC, wxPoint( -1, -1 ) );
@ -673,8 +673,8 @@ void WinEDA_PinPropertiesFrame::SetAttributsPin( bool draw,
continue;
if( Pin->m_Orient != CurrentPin->m_Orient )
continue;
DeleteOneLibraryDrawStruct( m_Parent->DrawPanel, NULL,
CurrentLibEntry, Pin, 0 );
CurrentLibEntry->RemoveDrawItem( (LibEDA_BaseStruct*) Pin );
}
}
} // end if unit
@ -705,8 +705,8 @@ void WinEDA_PinPropertiesFrame::SetAttributsPin( bool draw,
continue;
if( Pin->m_Orient != CurrentPin->m_Orient )
continue;
DeleteOneLibraryDrawStruct( m_Parent->DrawPanel, NULL,
CurrentLibEntry, Pin, 0 );
CurrentLibEntry->RemoveDrawItem( (LibEDA_BaseStruct*) Pin );
}
}
} // end if convert
@ -848,8 +848,9 @@ void WinEDA_LibeditFrame::GlobalSetPins( wxDC* DC,
{
LibDrawPin* Pin;
bool selected = ( MasterPin->m_Selected & IS_SELECTED ) != 0;
bool showPinText = true;
if( (CurrentLibEntry == NULL) || (MasterPin == NULL) )
if( ( CurrentLibEntry == NULL ) || ( MasterPin == NULL ) )
return;
if( MasterPin->Type() != COMPONENT_PIN_DRAW_TYPE )
return;
@ -868,8 +869,8 @@ void WinEDA_LibeditFrame::GlobalSetPins( wxDC* DC,
if( selected && (Pin->m_Selected & IS_SELECTED) == 0 )
continue;
DrawLibraryDrawStruct( DrawPanel, DC, CurrentLibEntry,
wxPoint( 0, 0 ), Pin, g_XorMode );
Pin->Draw( DrawPanel, DC, wxPoint( 0, 0 ), -1, g_XorMode,
&showPinText, DefaultTransformMatrix );
switch( id )
{
@ -886,7 +887,8 @@ void WinEDA_LibeditFrame::GlobalSetPins( wxDC* DC,
break;
}
DrawLibraryDrawStruct( DrawPanel, DC, CurrentLibEntry, wxPoint(0, 0), Pin, GR_DEFAULT_DRAWMODE );
Pin->Draw( DrawPanel, DC, wxPoint( 0, 0 ), -1, GR_DEFAULT_DRAWMODE,
&showPinText, DefaultTransformMatrix );
}
}
@ -1006,9 +1008,9 @@ bool WinEDA_LibeditFrame::TestPins( EDA_LibComponentStruct* LibEntry )
error++;
curr_pin->ReturnPinStringNum( StringPinNum );
msg.Printf( _( "Duplicate Pin %4.4s (Pin %s loc %d, %d, and Pin %s loc %d, %d)" ),
StringPinNum.GetData(),
curr_pin->m_PinName.GetData(), curr_pin->m_Pos.x, -curr_pin->m_Pos.y,
Pin->m_PinName.GetData(), Pin->m_Pos.x, -Pin->m_Pos.y );
StringPinNum.GetData(), curr_pin->m_PinName.GetData(),
curr_pin->m_Pos.x, -curr_pin->m_Pos.y,
Pin->m_PinName.GetData(), Pin->m_Pos.x, -Pin->m_Pos.y );
if( CurrentLibEntry->m_UnitCount > 1 )
{

32
eeschema/protos.h
View File

@ -57,23 +57,6 @@ void DrawingLibInGhost( WinEDA_DrawPanel* panel,
int Color,
bool DrawPinText );
void DrawLibEntry( WinEDA_DrawPanel* panel,
wxDC* DC,
EDA_LibComponentStruct* LibEntry,
const wxPoint& aOffset,
int Multi,
int convert,
int DrawMode,
int Color = -1 );
void DrawLibraryDrawStruct( WinEDA_DrawPanel* aPanel,
wxDC* aDC,
EDA_LibComponentStruct* aLibEntry,
wxPoint aPosition,
LibEDA_BaseStruct* aDrawItem,
int aDrawMode,
int aColor = -1 );
bool MapAngles( int* Angle1,
int* Angle2,
const int TransMat[2][2] );
@ -283,21 +266,6 @@ bool LocateAndDeleteItem( WinEDA_SchematicFrame* frame, wxDC* DC );
void EraseStruct( SCH_ITEM* DrawStruct, SCH_SCREEN* Window );
void DeleteAllMarkers( int type );
/* Effacement des marqueurs du type "type" */
void DeleteOneLibraryDrawStruct( WinEDA_DrawPanel* panel,
wxDC* DC, EDA_LibComponentStruct* LibEntry,
LibEDA_BaseStruct* DrawItem, int Affiche );
/* Routine d'effacement d'un "LibraryDrawStruct"
* (d'un element de dessin d'un composant )
* Parametres d'entree
* Pointeur sur le composant comportant la structure
* (Si NULL la structure a effacer est supposee non rattachee
* a un composant)
* Pointeur sur la structure a effacer
* Affiche (si != 0 Efface le graphique correspondant de l'ecran) */
/**************/
/* GETPART.CPP */

77
eeschema/symbdraw.cpp
View File

@ -1,7 +1,7 @@
/*********************************************************************/
/* EESchema - symbdraw.cpp */
/* EESchema - symbdraw.cpp */
/* Create, move .. graphic shapes used to build and draw a component */
/* (lines, arcs .. */
/* (lines, arcs .. */
/*********************************************************************/
#include "fctsys.h"
@ -60,12 +60,8 @@ void WinEDA_bodygraphics_PropertiesFrame::bodygraphics_PropertiesAccept( wxComma
m_Parent->DrawPanel->PrepareGraphicContext( &dc );
DrawLibraryDrawStruct( m_Parent->DrawPanel,
&dc,
CurrentLibEntry,
wxPoint( 0, 0 ),
CurrentDrawItem,
g_XorMode );
CurrentDrawItem->Draw( m_Parent->DrawPanel, &dc, wxPoint( 0, 0 ), -1,
g_XorMode, NULL, DefaultTransformMatrix );
if( g_FlDrawSpecificUnit )
CurrentDrawItem->m_Unit = CurrentUnit;
@ -113,12 +109,8 @@ void WinEDA_bodygraphics_PropertiesFrame::bodygraphics_PropertiesAccept( wxComma
m_Parent->GetScreen()->SetModify();
DrawLibraryDrawStruct( m_Parent->DrawPanel,
&dc,
CurrentLibEntry,
wxPoint( 0, 0 ),
CurrentDrawItem,
g_XorMode );
CurrentDrawItem->Draw( m_Parent->DrawPanel, &dc, wxPoint( 0, 0 ),
-1, g_XorMode, NULL, DefaultTransformMatrix );
}
Close();
@ -164,8 +156,11 @@ static void AbortSymbolTraceOn( WinEDA_DrawPanel* Panel, wxDC* DC )
Panel->m_Parent->RedrawActiveWindow( DC, TRUE );
}
else
DrawLibraryDrawStruct( Panel, DC, CurrentLibEntry, wxPoint( 0, 0 ),
CurrentDrawItem, g_XorMode );
{
CurrentDrawItem->Draw( Panel, DC, wxPoint( 0, 0 ), -1, g_XorMode,
NULL, DefaultTransformMatrix );
}
SAFE_DELETE( CurrentDrawItem );
}
else
@ -175,9 +170,9 @@ static void AbortSymbolTraceOn( WinEDA_DrawPanel* Panel, wxDC* DC )
Panel->GetScreen()->m_Curseur = StartCursor;
RedrawWhileMovingCursor( Panel, DC, TRUE );
Panel->GetScreen()->m_Curseur = curpos;
DrawLibraryDrawStruct( Panel, DC, CurrentLibEntry, wxPoint( 0, 0 ),
CurrentDrawItem, GR_DEFAULT_DRAWMODE );
CurrentDrawItem->Draw( Panel, DC, wxPoint( 0, 0 ), -1,
GR_DEFAULT_DRAWMODE, NULL,
DefaultTransformMatrix );
CurrentDrawItem->m_Flags = 0;
}
}
@ -311,9 +306,8 @@ LibEDA_BaseStruct* WinEDA_LibeditFrame::CreateGraphicItem( EDA_LibComponentStruc
else
{
StartMoveDrawSymbol( DC );
DrawLibraryDrawStruct( DrawPanel, DC, CurrentLibEntry,
wxPoint( 0, 0 ),
Text, g_XorMode );
Text->Draw( DrawPanel, DC, wxPoint( 0, 0 ), -1, g_XorMode, NULL,
DefaultTransformMatrix );
}
}
break;
@ -400,15 +394,15 @@ static void RedrawWhileMovingCursor( WinEDA_DrawPanel* panel,
/* Erase shape in the old positon*/
if( erase )
{
pos = ItemPreviousPos - StartCursor,
DrawLibraryDrawStruct( panel, DC, CurrentLibEntry, pos,
CurrentDrawItem, g_XorMode );
pos = ItemPreviousPos - StartCursor;
CurrentDrawItem->Draw( panel, DC, pos, -1, g_XorMode, NULL,
DefaultTransformMatrix );
}
/* Redraw moved shape */
pos = Screen->m_Curseur - StartCursor,
DrawLibraryDrawStruct( panel, DC, CurrentLibEntry, pos,
CurrentDrawItem, g_XorMode );
pos = Screen->m_Curseur - StartCursor;
CurrentDrawItem->Draw( panel, DC, pos, -1, g_XorMode, NULL,
DefaultTransformMatrix );
ItemPreviousPos = Screen->m_Curseur;
}
@ -514,7 +508,7 @@ void WinEDA_LibeditFrame::StartMoveDrawSymbol( wxDC* DC )
/****************************************************************/
/* Routine de Gestion des evenements souris lors de la creation */
/* d'un nouvel element type LibraryDrawStruct */
/* d'un nouvel element type LibraryDrawStruct */
/****************************************************************/
static void SymbolDisplayDraw( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
{
@ -543,8 +537,8 @@ static void SymbolDisplayDraw( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
}
else
{
DrawLibraryDrawStruct( panel, DC, CurrentLibEntry, wxPoint( 0, 0 ),
CurrentDrawItem, DrawMode );
CurrentDrawItem->Draw( panel, DC, wxPoint( 0, 0 ), -1, DrawMode,
NULL, DefaultTransformMatrix );
if( CurrentDrawItem->Type() == COMPONENT_ARC_DRAW_TYPE )
{
int Color = ReturnLayerColor( LAYER_DEVICE );
@ -621,8 +615,8 @@ static void SymbolDisplayDraw( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
}
else
{
DrawLibraryDrawStruct( panel, DC, CurrentLibEntry, wxPoint( 0, 0 ),
CurrentDrawItem, DrawMode );
CurrentDrawItem->Draw( panel, DC, wxPoint( 0, 0 ), -1, DrawMode,
NULL, DefaultTransformMatrix );
if( CurrentDrawItem->Type() == COMPONENT_ARC_DRAW_TYPE )
{
int Color = ReturnLayerColor( LAYER_DEVICE );
@ -719,8 +713,8 @@ void WinEDA_LibeditFrame::EndDrawGraphicItem( wxDC* DC )
MoveLibDrawItemAt( CurrentDrawItem, pos );
}
DrawLibEntry( DrawPanel, DC, CurrentLibEntry, wxPoint( 0, 0 ), CurrentUnit,
CurrentConvert, GR_DEFAULT_DRAWMODE );
CurrentLibEntry->Draw( DrawPanel, DC, wxPoint( 0, 0 ), CurrentUnit,
CurrentConvert, GR_DEFAULT_DRAWMODE );
CurrentDrawItem->m_Flags = 0;
CurrentDrawItem = NULL;
@ -824,15 +818,14 @@ void WinEDA_LibeditFrame::DeleteDrawPoly( wxDC* DC )
/* Used for deleting last entered segment while creating a Polyline
*/
{
if( CurrentDrawItem == NULL )
return;
if( CurrentDrawItem->Type() != COMPONENT_POLYLINE_DRAW_TYPE )
if( CurrentDrawItem == NULL
|| CurrentDrawItem->Type() != COMPONENT_POLYLINE_DRAW_TYPE )
return;
LibDrawPolyline* Poly = (LibDrawPolyline*) CurrentDrawItem;
DrawLibraryDrawStruct( DrawPanel, DC, CurrentLibEntry, wxPoint( 0, 0 ),
CurrentDrawItem, g_XorMode );
CurrentDrawItem->Draw( DrawPanel, DC, wxPoint( 0, 0 ), -1, g_XorMode,
NULL, DefaultTransformMatrix );
while( Poly->GetCornerCount() > 2 ) // First segment is kept, only its end point is changed
{
@ -847,6 +840,6 @@ void WinEDA_LibeditFrame::DeleteDrawPoly( wxDC* DC )
}
}
DrawLibraryDrawStruct( DrawPanel, DC, CurrentLibEntry, wxPoint( 0, 0 ),
CurrentDrawItem, g_XorMode );
CurrentDrawItem->Draw( DrawPanel, DC, wxPoint( 0, 0 ), -1, g_XorMode,
NULL, DefaultTransformMatrix );
}

116
eeschema/symbedit.cpp
View File

@ -8,7 +8,6 @@
/* fichier symbedit.cpp */
#include "fctsys.h"
#include "gr_basic.h"
#include "appl_wxstruct.h"
#include "common.h"
#include "class_drawpanel.h"
@ -22,12 +21,9 @@
#include "protos.h"
/* Routines locales */
static bool CompareSymbols( LibEDA_BaseStruct* DEntryRef,
LibEDA_BaseStruct* DEntryCompare );
/* Variables locales */
/*
* Read a component shape file (a symbol file *.sym )and add data (graphic
@ -40,10 +36,9 @@ void WinEDA_LibeditFrame::LoadOneSymbol( void )
{
EDA_LibComponentStruct* Component;
LibEDA_BaseStruct* DrawEntry;
wxString FullFileName, mask;
FILE* ImportFile;
wxString msg, err;
LibraryStruct* Lib;
FILE* ImportFile;
wxString msg, err;
LibraryStruct* Lib;
/* Exit if no library entry is selected or a command is in progress. */
if( CurrentLibEntry == NULL
@ -52,36 +47,29 @@ void WinEDA_LibeditFrame::LoadOneSymbol( void )
DrawPanel->m_IgnoreMouseEvents = TRUE;
mask = wxT( "*" ) + g_SymbolExtBuffer;
wxString default_lib_path = wxGetApp().ReturnLastVisitedLibraryPath();
wxString default_path = wxGetApp().ReturnLastVisitedLibraryPath();
FullFileName = EDA_FileSelector( _( "Import symbol drawings:" ),
default_lib_path, /* Chemin par defaut */
wxEmptyString, /* nom fichier par defaut */
g_SymbolExtBuffer, /* extension par defaut */
mask, /* Masque d'affichage */
this,
0,
TRUE
);
wxFileDialog dlg( this, _( "Import Symbol Drawings" ), default_path,
wxEmptyString, SymbolFileWildcard,
wxFD_OPEN | wxFD_FILE_MUST_EXIST );
if( dlg.ShowModal() == wxID_CANCEL )
return;
GetScreen()->m_Curseur = wxPoint( 0, 0 );
DrawPanel->MouseToCursorSchema();
DrawPanel->m_IgnoreMouseEvents = FALSE;
if( FullFileName.IsEmpty() )
return;
wxFileName fn = FullFileName;
wxFileName fn = dlg.GetPath();
wxGetApp().SaveLastVisitedLibraryPath( fn.GetPath() );
/* Load data */
ImportFile = wxFopen( FullFileName, wxT( "rt" ) );
ImportFile = wxFopen( fn.GetFullPath(), wxT( "rt" ) );
if( ImportFile == NULL )
{
msg.Printf( _( "Failed to open Symbol File <%s>" ),
(const wxChar*) FullFileName );
(const wxChar*) fn.GetFullPath() );
DisplayError( this, msg );
return;
}
@ -164,43 +152,43 @@ void WinEDA_LibeditFrame::LoadOneSymbol( void )
*/
void WinEDA_LibeditFrame::SaveOneSymbol()
{
EDA_LibComponentStruct* LibEntry = CurrentLibEntry;
int Unit = CurrentUnit, convert = CurrentConvert;
LibEDA_BaseStruct* DrawEntry;
wxString FullFileName, mask;
wxString msg;
FILE* ExportFile;
LibEDA_BaseStruct* DrawEntry;
wxString msg;
FILE* ExportFile;
if( LibEntry->m_Drawings == NULL )
if( CurrentLibEntry->m_Drawings == NULL )
return;
/* Creation du fichier symbole */
wxString default_lib_path = wxGetApp().ReturnLastVisitedLibraryPath();
mask = wxT( "*" ) + g_SymbolExtBuffer;
FullFileName = EDA_FileSelector( _( "Export symbol drawings:" ),
default_lib_path, /* Chemin par defaut */
wxEmptyString, /* nom fichier par defaut */
g_SymbolExtBuffer, /* extension par defaut */
mask, /* Masque d'affichage */
this,
wxFD_SAVE,
TRUE
);
if( FullFileName.IsEmpty() )
wxString default_path = wxGetApp().ReturnLastVisitedLibraryPath();
wxFileDialog dlg( this, _( "Export Symbol Drawings" ), default_path,
CurrentLibEntry->m_Name.m_Text, SymbolFileWildcard,
wxFD_SAVE | wxFD_OVERWRITE_PROMPT );
if( dlg.ShowModal() == wxID_CANCEL )
return;
wxFileName fn = FullFileName;
wxFileName fn = dlg.GetPath();
/* The GTK file chooser doesn't return the file extension added to
* file name so add it here. */
if( fn.GetExt().IsEmpty() )
fn.SetExt( SymbolFileExtension );
wxGetApp().SaveLastVisitedLibraryPath( fn.GetPath() );
ExportFile = wxFopen( FullFileName, wxT( "wt" ) );
ExportFile = wxFopen( fn.GetFullPath(), wxT( "wt" ) );
if( ExportFile == NULL )
{
msg.Printf( _( "Unable to create <%s>" ), FullFileName.GetData() );
msg.Printf( _( "Unable to create <%s>" ),
(const wxChar*) fn.GetFullPath() );
DisplayError( this, msg );
return;
}
msg.Printf( _( "Save Symbol in [%s]" ), FullFileName.GetData() );
msg.Printf( _( "Save Symbol in [%s]" ), (const wxChar*) fn.GetPath() );
Affiche_Message( msg );
/* Creation de l'entete de la librairie */
@ -211,39 +199,40 @@ void WinEDA_LibeditFrame::SaveOneSymbol()
/* Creation du commentaire donnant le nom du composant */
fprintf( ExportFile, "# SYMBOL %s\n#\n",
(const char*) LibEntry->m_Name.m_Text.GetData() );
CONV_TO_UTF8( CurrentLibEntry->m_Name.m_Text ) );
/* Generation des lignes utiles */
fprintf( ExportFile, "DEF %s",
(const char*) LibEntry->m_Name.m_Text.GetData() );
if( !LibEntry->m_Prefix.m_Text.IsEmpty() )
CONV_TO_UTF8( CurrentLibEntry->m_Name.m_Text ) );
if( !CurrentLibEntry->m_Prefix.m_Text.IsEmpty() )
fprintf( ExportFile, " %s",
(const char*) LibEntry->m_Prefix.m_Text.GetData() );
CONV_TO_UTF8( CurrentLibEntry->m_Prefix.m_Text ) );
else
fprintf( ExportFile, " ~" );
fprintf( ExportFile, " %d %d %c %c %d %d %c\n",
0, /* unused */
LibEntry->m_TextInside,
LibEntry->m_DrawPinNum ? 'Y' : 'N',
LibEntry->m_DrawPinName ? 'Y' : 'N',
CurrentLibEntry->m_TextInside,
CurrentLibEntry->m_DrawPinNum ? 'Y' : 'N',
CurrentLibEntry->m_DrawPinName ? 'Y' : 'N',
1, 0 /* unused */, 'N' );
/* Position / orientation / visibilite des champs */
LibEntry->m_Prefix.Save( ExportFile );
LibEntry->m_Name.Save( ExportFile );
CurrentLibEntry->m_Prefix.Save( ExportFile );
CurrentLibEntry->m_Name.Save( ExportFile );
DrawEntry = CurrentLibEntry->m_Drawings;
DrawEntry = LibEntry->m_Drawings;
if( DrawEntry )
{
fprintf( ExportFile, "DRAW\n" );
for( ; DrawEntry != NULL; DrawEntry = DrawEntry->Next() )
{
/* Elimination des elements non relatifs a l'unite */
if( Unit && DrawEntry->m_Unit && ( DrawEntry->m_Unit != Unit ) )
if( CurrentUnit && DrawEntry->m_Unit
&& ( DrawEntry->m_Unit != CurrentUnit ) )
continue;
if( convert && DrawEntry->m_Convert
&& ( DrawEntry->m_Convert != convert ) )
if( CurrentConvert && DrawEntry->m_Convert
&& ( DrawEntry->m_Convert != CurrentConvert ) )
continue;
DrawEntry->Save( ExportFile );
@ -251,6 +240,7 @@ void WinEDA_LibeditFrame::SaveOneSymbol()
fprintf( ExportFile, "ENDDRAW\n" );
}
fprintf( ExportFile, "ENDDEF\n" );
fclose( ExportFile );
}
@ -281,7 +271,7 @@ void SuppressDuplicateDrawItem( EDA_LibComponentStruct* LibEntry )
{
if( CompareSymbols( DEntryRef, DEntryCompare ) == TRUE )
{
DeleteOneLibraryDrawStruct( NULL, DC, LibEntry, DEntryRef, 1 );
LibEntry->RemoveDrawItem( DEntryRef, NULL, DC );
deleted = TRUE;
break;
}
@ -474,7 +464,7 @@ void WinEDA_LibeditFrame::PlaceAncre()
break;
default:
;
break;
}
DrawEntry = DrawEntry->Next();
}

8
eeschema/viewlibs.cpp
View File

@ -310,8 +310,8 @@ void WinEDA_ViewlibFrame::RedrawActiveWindow( wxDC* DC, bool EraseBg )
g_ViewUnit = 1;
if( g_ViewConvert < 1 )
g_ViewConvert = 1;
DrawLibEntry( DrawPanel, DC, LibEntry, wxPoint( 0, 0 ),
g_ViewUnit, g_ViewConvert, GR_DEFAULT_DRAWMODE );
LibEntry->Draw( DrawPanel, DC, wxPoint( 0, 0 ), g_ViewUnit,
g_ViewConvert, GR_DEFAULT_DRAWMODE );
LibEntry->m_Name.m_Text = RealName;
}
}
@ -319,8 +319,8 @@ void WinEDA_ViewlibFrame::RedrawActiveWindow( wxDC* DC, bool EraseBg )
{
Msg.Printf( _( "Current Part: <%s>" ),
ViewCmpEntry->m_Name.m_Text.GetData() );
DrawLibEntry( DrawPanel, DC, LibEntry, wxPoint( 0, 0 ),
g_ViewUnit, g_ViewConvert, GR_DEFAULT_DRAWMODE );
LibEntry->Draw( DrawPanel, DC, wxPoint( 0, 0 ), g_ViewUnit,
g_ViewConvert, GR_DEFAULT_DRAWMODE );
}
AfficheDoc( this, ViewCmpEntry->m_Doc, ViewCmpEntry->m_KeyWord );
}