kicad/eeschema/eelibs_draw_components.cpp

/****************************************/
/* Modules to handle component drawing. */
/****************************************/

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

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

#define UNVISIBLE_COLOR DARKGRAY

//#define DRAW_ARC_WITH_ANGLE		// Used to draw arcs


/* Fonctions locales */

/* Descr component <DUMMY> used when a component is not found in library,
 *  to draw a dummy shape*/

/*
 *  This component is a 400 mils square with the text ??
 *  DEF DUMMY U 0 40 Y Y 1 0 N
 *  F0 "U" 0 -350 60 H V
 *  F1 "DUMMY" 0 350 60 H V
 *  DRAW
 *  T 0 0 0 150 0 0 0 ??
 *  S -200 200 200 -200 0 1 0
 *  ENDDRAW
 *  ENDDEF
 */

static int  s_ItemSelectColor = BROWN;

static EDA_LibComponentStruct* DummyCmp;
static int* Buf_Poly_Drawings, Buf_Poly_Size;  // Used fo polyline drawings
static void DrawLibPartAux( WinEDA_DrawPanel* panel, wxDC* DC,
                            SCH_COMPONENT* Component,
                            EDA_LibComponentStruct* Entry,
                            const wxPoint& Pos,
                            int TransMat[2][2],
                            int Multi, int convert,
                            int DrawMode, int Color = -1, bool DrawPinText = TRUE );

/******************************/
static void CreateDummyCmp()
/******************************/
{
    DummyCmp = new              EDA_LibComponentStruct( NULL );

    LibDrawSquare* Square = new LibDrawSquare();

    Square->m_Pos   = wxPoint( -200, 200 );
    Square->m_End   = wxPoint( 200, -200 );
    Square->m_Width = 4;

    LibDrawText* Text = new LibDrawText();

    Text->m_Size.x = Text->m_Size.y = 150;
    Text->m_Text   = wxT( "??" );

    DummyCmp->m_Drawings = Square;
    Square->Pnext = Text;
}


/*************************************************************/
void DrawLibEntry( WinEDA_DrawPanel* panel, wxDC* DC,
                   EDA_LibComponentStruct* LibEntry,
                   int posX, int posY,
                   int Multi, int convert,
                   int DrawMode, int Color )
/**************************************************************/

/* 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
 */
{
    int           color;
    int           TransMat[2][2];
    wxString      Prefix;
    LibDrawField* Field;
    wxPoint       text_pos;

    /* Orientation normale */
    TransMat[0][0] = 1; TransMat[1][1] = -1;
    TransMat[1][0] = TransMat[0][1] = 0;

    DrawLibPartAux( panel, DC, NULL, LibEntry, wxPoint( posX, posY ),
                    TransMat, 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 = UNVISIBLE_COLOR;
    }
    else
    {
        if( Color >= 0 )
            color = Color;
        else
            color = ReturnLayerColor( LAYER_REFERENCEPART );
    }

    if( LibEntry->m_UnitCount > 1 )
        Prefix.Printf( wxT( "%s?%c" ), LibEntry->m_Prefix.m_Text.GetData(), Multi + 'A' - 1 );
    else
        Prefix = LibEntry->m_Prefix.m_Text + wxT( "?" );

    text_pos.x = LibEntry->m_Prefix.m_Pos.x + posX;
    text_pos.y = posY - LibEntry->m_Prefix.m_Pos.y;
    int LineWidth = MAX( LibEntry->m_Prefix.m_Width, g_DrawMinimunLineWidth );
    if( (LibEntry->m_Prefix.m_Flags & IS_MOVED) == 0 )
        DrawGraphicText( panel, DC, text_pos,
                         color, LibEntry->m_Prefix.m_Text.GetData(),
                         LibEntry->m_Prefix.m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
                         LibEntry->m_Prefix.m_Size,
                         LibEntry->m_Prefix.m_HJustify, LibEntry->m_Prefix.m_VJustify, LineWidth );

    if( LibEntry->m_Name.m_Attributs & TEXT_NO_VISIBLE )
    {
        if( Color >= 0 )
            color = Color;
        else
            color = UNVISIBLE_COLOR;
    }
    else
    {
        if( Color >= 0 )
            color = Color;
        else
            color = ReturnLayerColor( LAYER_VALUEPART );
    }

    text_pos.x = LibEntry->m_Name.m_Pos.x + posX;
    text_pos.y = posY - LibEntry->m_Name.m_Pos.y;
    LineWidth  = MAX( LibEntry->m_Name.m_Width, g_DrawMinimunLineWidth );
    if( (LibEntry->m_Name.m_Flags & IS_MOVED) == 0 )
        DrawGraphicText( panel, DC, text_pos,
                         color, LibEntry->m_Name.m_Text.GetData(),
                         LibEntry->m_Name.m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
                         LibEntry->m_Name.m_Size,
                         LibEntry->m_Name.m_HJustify, LibEntry->m_Name.m_VJustify, LineWidth );

    for( Field = LibEntry->Fields; Field != NULL; Field = (LibDrawField*) Field->Pnext )
    {
        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 = UNVISIBLE_COLOR;
        }
        else
        {
            if( Color >= 0 )
                color = Color;
            else
                color = ReturnLayerColor( LAYER_FIELDS );
        }

        text_pos.x = Field->m_Pos.x + posX;
        text_pos.y = posY - Field->m_Pos.y;
        LineWidth  = MAX( Field->m_Width, g_DrawMinimunLineWidth );
        DrawGraphicText( panel, DC, text_pos,
                         color, Field->m_Text,
                         Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
                         Field->m_Size,
                         Field->m_HJustify, Field->m_VJustify, LineWidth );
    }

    // Trac<61> de l'ancre
    int len = 3 * panel->GetZoom();
    GRLine( &panel->m_ClipBox, DC, posX, posY - len, posX, posY + len, 0, color );
    GRLine( &panel->m_ClipBox, DC, posX - len, posY, posX + len, posY, 0, color );
}


/*****************************************************************************
* Routine to draw the given part at given position, transformed/mirror as	 *
* specified, and in the given drawing mode. Only this one is visible...		 *
*****************************************************************************/
void SCH_COMPONENT::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
                                   const wxPoint& offset, int DrawMode, int Color )
{
    EDA_LibComponentStruct* Entry;
    int  ii;
    bool dummy = FALSE;

    if( ( Entry = FindLibPart( m_ChipName.GetData(), wxEmptyString, FIND_ROOT ) ) == NULL )
    {   /* composant non trouve, on affiche un composant "dummy" */
        dummy = TRUE;
        if( DummyCmp == NULL )
            CreateDummyCmp();
        Entry = DummyCmp;
    }

    DrawLibPartAux( panel, DC, this, Entry, m_Pos + offset,
                    m_Transform,
                    dummy ? 0 : m_Multi,
                    dummy ? 0 : m_Convert,
                    DrawMode );

    /* Trace des champs, avec placement et orientation selon orient. du
     *  composant
     */

    if( ( (m_Field[REFERENCE].m_Attributs & TEXT_NO_VISIBLE) == 0 )
       && !(m_Field[REFERENCE].m_Flags & IS_MOVED) )
    {
        if( Entry->m_UnitCount > 1 )
        {
            m_Field[REFERENCE].m_AddExtraText = true;
            m_Field[REFERENCE].Draw( panel, DC, offset, DrawMode );
        }
        else
        {
            m_Field[REFERENCE].m_AddExtraText = false;
            m_Field[REFERENCE].Draw( panel, DC, offset, DrawMode );
        }
    }

    for( ii = VALUE; ii < NUMBER_OF_FIELDS; ii++ )
    {
        if( m_Field[ii].m_Flags & IS_MOVED )
            continue;
        m_Field[ii].Draw( panel, DC, offset, DrawMode );
    }
}


/***********************************************************/
void    PartTextStruct::Draw( WinEDA_DrawPanel* panel,
                          wxDC*             DC,
                          const wxPoint&    offset,
                          int               DrawMode,
                          int               Color)
/***********************************************************/

/* Routine de trace des textes type Field du composant.
 *  entree:
 *      DrawMode: mode de trace
 */
{
    int     orient, color;

    wxPoint pos;    /* Position des textes */
    SCH_COMPONENT* DrawLibItem = (SCH_COMPONENT*) m_Parent;
    int     hjustify, vjustify;
    int     LineWidth = MAX( m_Width, g_DrawMinimunLineWidth );

    if( m_Attributs & TEXT_NO_VISIBLE )
        return;
    if( IsVoid() )
        return;

    GRSetDrawMode( DC, DrawMode );

    /* Calcul de la position des textes, selon orientation du composant */
    orient   = m_Orient;
    hjustify = m_HJustify; vjustify = m_VJustify;
    pos    = m_Pos - DrawLibItem->m_Pos;

    pos    = DrawLibItem->GetScreenCoord( pos );
    pos += DrawLibItem->m_Pos;

    /* Y a t-il rotation (pour l'orientation, la justification)*/
    if( DrawLibItem->m_Transform[0][1] )  // Rotation du composant de 90deg
    {
        if( orient == TEXT_ORIENT_HORIZ )
            orient = TEXT_ORIENT_VERT;
        else
            orient = TEXT_ORIENT_HORIZ;
        /* Y a t-il rotation, miroir (pour les justifications)*/
        EXCHG( hjustify, vjustify );
        if( DrawLibItem->m_Transform[1][0] < 0 )
            vjustify = -vjustify;
        if( DrawLibItem->m_Transform[1][0] > 0 )
            hjustify = -hjustify;
    }
    else
    {
        /* Texte horizontal: Y a t-il miroir (pour les justifications)*/
        if( DrawLibItem->m_Transform[0][0] < 0 )
            hjustify = -hjustify;
        if( DrawLibItem->m_Transform[1][1] > 0 )
            vjustify = -vjustify;
    }

    if( m_FieldId == REFERENCE )
        color = ReturnLayerColor( LAYER_REFERENCEPART );
    else if( m_FieldId == VALUE )
        color = ReturnLayerColor( LAYER_VALUEPART );
    else
        color = ReturnLayerColor( LAYER_FIELDS );
    if( !m_AddExtraText || (m_FieldId != REFERENCE) )
    {
        DrawGraphicText( panel, DC, pos, color, m_Text.GetData(),
                         orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
                         m_Size,
                         hjustify, vjustify, LineWidth );
    }
    else // Si il y a plusieurs parts par boitier, ajouter a la reference l'identification de la selection ( A, B ... )
    {
            /* On ajoute alors A ou B ... a la reference */
        wxString fulltext = m_Text;
        fulltext.Append( 'A' - 1 + DrawLibItem->m_Multi );
        DrawGraphicText( panel, DC, pos, color, fulltext.GetData(),
                         orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
                         m_Size,
                         hjustify, vjustify, LineWidth );
    }
}


/********************************************************************************/
EDA_LibComponentStruct* FindLibPart( const wxChar* Name, const wxString& LibName, int Alias )
/********************************************************************************/

/*
 *  Routine to find a part in one of the libraries given its name.
 *  Name = Name of part.
 *  LibName = Name of Lib; if "": seach in all libs
 *  Alias = Flag: si flag != 0, retourne un pointeur sur une part ou un alias
 *                si flag = 0, retourne un pointeur sur une part meme si le nom
 *                correspond a un alias
 *  Alias = FIND_ROOT, ou Alias = FIND_ALIAS
 */
{
    EDA_LibComponentStruct* Entry;

    static EDA_LibComponentStruct DummyEntry( wxEmptyString );  /* Used only to call PQFind. */

    LibraryStruct* Lib = g_LibraryList;

    DummyEntry.m_Drawings    = NULL;/* Used only to call PQFind. */
    DummyEntry.m_Name.m_Text = Name;

    PQCompFunc( (PQCompFuncType) LibraryEntryCompare );

    Entry = NULL;
    FindLibName.Empty();

    while( Lib )
    {
        if( !LibName.IsEmpty() )
        {
            if( Lib->m_Name != LibName )
            {
                Lib = Lib->m_Pnext;
                continue;
            }
        }

        if( Lib == NULL )
            break;

        Entry = (EDA_LibComponentStruct*) PQFind( Lib->m_Entries, &DummyEntry );
        if( Entry != NULL )
        {
            FindLibName = Lib->m_Name;
            break;
        }

        Lib = Lib->m_Pnext;
    }

    /* Si le nom est un alias, recherche du vrai composant */
    if( Entry )
    {
        if( (Entry->Type != ROOT ) && (Alias == FIND_ROOT) )
            Entry = FindLibPart( ( (EDA_LibCmpAliasStruct*) Entry )->m_RootName.GetData(),
                                Lib->m_Name, FIND_ROOT );
    }

    return Entry;
}


/*****************************************************************************
* Routine to draw the given part at given position, transformed/mirror as
* specified, and in the given drawing mode.
* if Color < 0: Draw in normal color
* else draw  in color = Color
*****************************************************************************/
/* DrawMode  = GrXOR, GrOR ..*/
void DrawLibPartAux( WinEDA_DrawPanel* panel, wxDC* DC,
                     SCH_COMPONENT* Component,
                     EDA_LibComponentStruct* Entry,
                     const wxPoint& Pos,
                     int TransMat[2][2],
                     int Multi, int convert, int DrawMode,
                     int Color, bool DrawPinText )
{
    int i, x1, y1, x2, y2, t1, t2, orient;
    LibEDA_BaseStruct* DEntry = NULL;
    int CharColor;
    int fill_option;
    int SetHightColor;
    int LineWidth;

//#define GETCOLOR(l) Color < 0 ? (ReturnLayerColor(l)| SetHightColor) : Color;
#define GETCOLOR( l ) Color < 0 ? SetHightColor ?\
    s_ItemSelectColor : (ReturnLayerColor( l ) | SetHightColor) : Color;

    if( Entry->m_Drawings == NULL )
        return;
    GRSetDrawMode( DC, DrawMode );

    for( DEntry = Entry->m_Drawings; DEntry != NULL; DEntry = DEntry->Next() )
    {
        /* Elimination des elements non relatifs a l'unite */
        if( Multi && DEntry->m_Unit && (DEntry->m_Unit != Multi) )
            continue;

        if( convert && DEntry->m_Convert && (DEntry->m_Convert != convert) )
            continue;

        if( DEntry->m_Flags & IS_MOVED )
            continue;                               // Element en deplacement non trace

        SetHightColor = (DEntry->m_Selected & IS_SELECTED) ? HIGHT_LIGHT_FLAG : 0;
        LineWidth = MAX( DEntry->m_Width, g_DrawMinimunLineWidth );

        switch( DEntry->Type() )
        {
        case COMPONENT_ARC_DRAW_TYPE:
        {
            int         xc, yc, x2, y2;
            LibDrawArc* Arc = (LibDrawArc*) DEntry;
            CharColor = GETCOLOR( LAYER_DEVICE );
            xc = Pos.x + TransMat[0][0] * Arc->m_Pos.x +
                 TransMat[0][1] * Arc->m_Pos.y;
            yc = Pos.y + TransMat[1][0] * Arc->m_Pos.x +
                 TransMat[1][1] * Arc->m_Pos.y;
            x2 = Pos.x + TransMat[0][0] * Arc->m_ArcStart.x +
                 TransMat[0][1] * Arc->m_ArcStart.y;;
            y2 = Pos.y + TransMat[1][0] * Arc->m_ArcStart.x +
                 TransMat[1][1] * Arc->m_ArcStart.y;
            x1 = Pos.x + TransMat[0][0] * Arc->m_ArcEnd.x +
                 TransMat[0][1] * Arc->m_ArcEnd.y;;
            y1 = Pos.y + TransMat[1][0] * Arc->m_ArcEnd.x +
                 TransMat[1][1] * Arc->m_ArcEnd.y;
            t1 = Arc->t1; t2 = Arc->t2;
            bool swap = MapAngles( &t1, &t2, TransMat );
            if( swap )
            {
                EXCHG( x1, x2 ); EXCHG( y1, y2 )
            }
            fill_option = Arc->m_Fill & (~g_PrintFillMask);
            if( Color < 0 )         // Normal Color Layer
            {
                if( (fill_option == FILLED_WITH_BG_BODYCOLOR) && !g_IsPrinting )
                    GRFilledArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
                                Arc->m_Rayon, Arc->m_Width, CharColor,
                                ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
                else if( fill_option == FILLED_SHAPE )
                    GRFilledArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
                                 Arc->m_Rayon, CharColor, CharColor );
#ifdef DRAW_ARC_WITH_ANGLE
                else
                    GRArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
                           Arc->m_Rayon, LineWidth, CharColor );
#else
                else
                    GRArc1( &panel->m_ClipBox, DC, x1, y1, x2, y2,
                            xc, yc, LineWidth, CharColor );
#endif
            }
#ifdef DRAW_ARC_WITH_ANGLE
            else
                GRArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
                       Arc->m_Rayon, Circle->m_Width, CharColor );
#else
            else
                GRArc1( &panel->m_ClipBox, DC, x1, y1, x2, y2,
                        xc, yc, Arc->m_Width, CharColor );
#endif
        }
            break;

        case COMPONENT_CIRCLE_DRAW_TYPE:
        {
            LibDrawCircle* Circle = (LibDrawCircle*) DEntry;
            CharColor = GETCOLOR( LAYER_DEVICE );

            x1 = Pos.x + TransMat[0][0] * Circle->m_Pos.x +
                 TransMat[0][1] * Circle->m_Pos.y;
            y1 = Pos.y + TransMat[1][0] * Circle->m_Pos.x +
                 TransMat[1][1] * Circle->m_Pos.y;

            fill_option = Circle->m_Fill & (~g_PrintFillMask);
            if( Color < 0 )
            {
                if( (fill_option == FILLED_WITH_BG_BODYCOLOR) && !g_IsPrinting )
                    GRFilledCircle( &panel->m_ClipBox, DC, x1, y1,
                                   Circle->m_Rayon, LineWidth, CharColor,
                                   ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
                else if( fill_option == FILLED_SHAPE )
                    GRFilledCircle( &panel->m_ClipBox, DC, x1, y1,
                                    Circle->m_Rayon, 0, CharColor, CharColor );
                else
                    GRCircle( &panel->m_ClipBox, DC, x1, y1,
                              Circle->m_Rayon, LineWidth, CharColor );
            }
            else
                GRCircle( &panel->m_ClipBox, DC, x1, y1,
                          Circle->m_Rayon, LineWidth, CharColor );
        }
            break;

        case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
        {
            LibDrawText* Text = (LibDrawText*) DEntry;
            CharColor = GETCOLOR( LAYER_DEVICE );

            /* The text orientation may need to be flipped if the
             *  transformation matrix cuases xy axes to be flipped. */
            t1 = (TransMat[0][0] != 0) ^ (Text->m_Horiz != 0);

            x1 = Pos.x + TransMat[0][0] * Text->m_Pos.x
                 + TransMat[0][1] * Text->m_Pos.y;
            y1 = Pos.y + TransMat[1][0] * Text->m_Pos.x
                 + TransMat[1][1] * Text->m_Pos.y;

            DrawGraphicText( panel, DC, wxPoint( x1, y1 ), CharColor, Text->m_Text,
                             t1 ? TEXT_ORIENT_HORIZ : TEXT_ORIENT_VERT,
                             Text->m_Size,
                             GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, LineWidth );
        }
            break;

        case COMPONENT_RECT_DRAW_TYPE:
        {
            LibDrawSquare* Square = (LibDrawSquare*) DEntry;
            CharColor = GETCOLOR( LAYER_DEVICE );

            x1 = Pos.x + TransMat[0][0] * Square->m_Pos.x
                 + TransMat[0][1] * Square->m_Pos.y;
            y1 = Pos.y + TransMat[1][0] * Square->m_Pos.x
                 + TransMat[1][1] * Square->m_Pos.y;
            x2 = Pos.x + TransMat[0][0] * Square->m_End.x
                 + TransMat[0][1] * Square->m_End.y;
            y2 = Pos.y + TransMat[1][0] * Square->m_End.x
                 + TransMat[1][1] * Square->m_End.y;
            fill_option = Square->m_Fill & (~g_PrintFillMask);
            if( Color < 0 )
            {
                if( (fill_option == FILLED_WITH_BG_BODYCOLOR) && !g_IsPrinting )
                    GRFilledRect( &panel->m_ClipBox, DC, x1, y1, x2, y2,
                                 CharColor, LineWidth,
                                 ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
                else if( fill_option == FILLED_SHAPE )
                    GRFilledRect( &panel->m_ClipBox, DC, x1, y1, x2, y2,
                                  CharColor, CharColor );
                else
                    GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2,
                            LineWidth, CharColor );
            }
            else
                GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2,
                        LineWidth, CharColor );
        }
            break;

        case COMPONENT_PIN_DRAW_TYPE:     /* Trace des Pins */
        {
            LibDrawPin* Pin = (LibDrawPin*) DEntry;
            if( Pin->m_Attributs & PINNOTDRAW )
            {
                if( /*(GetScreen()->m_Type == SCHEMATIC_FRAME )
                   &&*/ !g_ShowAllPins )
                    break;
            }

            /* Calcul de l'orientation reelle de la Pin */
            orient = Pin->ReturnPinDrawOrient( TransMat );

            /* Calcul de la position du point de reference */
            x2 = Pos.x + (TransMat[0][0] * Pin->m_Pos.x)
                 + (TransMat[0][1] * Pin->m_Pos.y);
            y2 = Pos.y + (TransMat[1][0] * Pin->m_Pos.x)
                 + (TransMat[1][1] * Pin->m_Pos.y);

            /* Dessin de la pin et du symbole special associe */
            CharColor = GETCOLOR( LAYER_PIN );
            Pin->DrawPinSymbol( panel, DC, wxPoint( x2, y2 ), orient, DrawMode, CharColor );

            if( DrawPinText )
            {
                wxPoint pinpos( x2, y2 );

                CharColor = SetHightColor ? s_ItemSelectColor : Color;
                Pin->DrawPinTexts( panel, DC, pinpos, orient,
                                   Entry->m_TextInside,
                                   Entry->m_DrawPinNum, Entry->m_DrawPinName,
                                   CharColor, DrawMode );
            }
        }
            break;

        case COMPONENT_POLYLINE_DRAW_TYPE:
        {
            LibDrawPolyline* polyline = (LibDrawPolyline*) DEntry;
            CharColor = GETCOLOR( LAYER_DEVICE );
            if( Buf_Poly_Drawings == NULL )
            {
                Buf_Poly_Size     = polyline->n;
                Buf_Poly_Drawings = (int*) MyMalloc( sizeof(int) * 2 * Buf_Poly_Size );
            }
            else if( Buf_Poly_Size < polyline->n )
            {
                Buf_Poly_Size     = polyline->n;
                Buf_Poly_Drawings = (int*) realloc( Buf_Poly_Drawings,
                                                    sizeof(int) * 2 * Buf_Poly_Size );
            }
            for( i = 0; i < polyline->n; i++ )
            {
                Buf_Poly_Drawings[i * 2] = Pos.x +
                                           TransMat[0][0] * polyline->PolyList[i * 2] +
                                           TransMat[0][1] * polyline->PolyList[i * 2 + 1];
                Buf_Poly_Drawings[i * 2 + 1] = Pos.y +
                                               TransMat[1][0] * polyline->PolyList[i * 2] +
                                               TransMat[1][1] * polyline->PolyList[i * 2 + 1];
            }

            fill_option = polyline->m_Fill & (~g_PrintFillMask);
            if( Color < 0 )
            {
                if( (fill_option == FILLED_WITH_BG_BODYCOLOR) && !g_IsPrinting )
                    GRPoly( &panel->m_ClipBox, DC, polyline->n,
                           Buf_Poly_Drawings, 1, LineWidth, CharColor,
                           ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
                else if( fill_option == FILLED_SHAPE )
                    GRPoly( &panel->m_ClipBox, DC, polyline->n,
                            Buf_Poly_Drawings, 1, LineWidth, CharColor, CharColor );
                else
                    GRPoly( &panel->m_ClipBox, DC, polyline->n,
                            Buf_Poly_Drawings, 0, LineWidth, CharColor, CharColor );
            }
            else
                GRPoly( &panel->m_ClipBox, DC, polyline->n,
                        Buf_Poly_Drawings, 0, LineWidth, CharColor, CharColor );
        }
            break;

        default:
            wxBell();
            break;
        }

        /* Fin Switch */
    }

    /* Fin Boucle de dessin */
    if( g_DebugLevel > 4 ) /* Draw the component boundary box */
    {
        EDA_Rect BoundaryBox;
        if( Component )
            BoundaryBox = Component->GetBoundaryBox();
        else
            BoundaryBox = Entry->GetBoundaryBox( Multi, convert );
        x1 = BoundaryBox.GetX();
        y1 = BoundaryBox.GetY();
        x2 = BoundaryBox.GetRight();
        y2 = BoundaryBox.GetBottom();
        GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2, BROWN );
        BoundaryBox = Component->m_Field[REFERENCE].GetBoundaryBox();
        x1 = BoundaryBox.GetX();
        y1 = BoundaryBox.GetY();
        x2 = BoundaryBox.GetRight();
        y2 = BoundaryBox.GetBottom();
        GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2, BROWN );
        BoundaryBox = Component->m_Field[VALUE].GetBoundaryBox();
        x1 = BoundaryBox.GetX();
        y1 = BoundaryBox.GetY();
        x2 = BoundaryBox.GetRight();
        y2 = BoundaryBox.GetBottom();
        GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2, BROWN );
    }
}


/********************************************************************************/
void LibDrawPin::DrawPinSymbol( WinEDA_DrawPanel* panel, wxDC* DC,
                                const wxPoint& pin_pos, int orient, int DrawMode, int Color )
/*******************************************************************************/

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


    if( Color >= 0 )
        color = Color;
    else
        color = ReturnLayerColor( LAYER_PIN );
    GRSetDrawMode( DC, DrawMode );


    MapX1 = MapY1 = 0; x1 = posX; y1 = posY;

    switch( orient )
    {
    case PIN_UP:
        y1 = posY - len; MapY1 = 1;
        break;

    case PIN_DOWN:
        y1 = posY + len; MapY1 = -1;
        break;

    case PIN_LEFT:
        x1 = posX - len, MapX1 = 1;
        break;

    case PIN_RIGHT:
        x1 = posX + len; MapX1 = -1;
        break;
    }

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

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

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

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


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

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


/*****************************************************************************
* Routine to rotate the given angular direction by the given Transformation. *
* Input (and output) angles must be as follows:								 *
*	Unit is 0.1 degre														 *
* Angle1 in [0..3600], Angle2 > Angle1 in [0..7200]. Arc is assumed to be less *
* than 180.0 degrees.															 *
* Algorithm:																 *
* Map the angles to a point on the unit circle which is mapped using the	 *
* transform (only mirror and rotate so it remains on the unit circle) to	 *
* a new point which is used to detect new angle.							 *
*****************************************************************************/
bool MapAngles( int* Angle1, int* Angle2, int TransMat[2][2] )
{
    int    Angle, Delta;
    double x, y, t;
    bool   swap = FALSE;

    Delta = *Angle2 - *Angle1;
    if( Delta >= 1800 )
    {
        *Angle1 -= 1;
        *Angle2 += 1;
    }

    x = cos( *Angle1 * M_PI / 1800.0 );
    y = sin( *Angle1 * M_PI / 1800.0 );
    t = x * TransMat[0][0] + y * TransMat[0][1];
    y = x * TransMat[1][0] + y * TransMat[1][1];
    x = t;
    *Angle1 = (int) (atan2( y, x ) * 1800.0 / M_PI + 0.5);

    x = cos( *Angle2 * M_PI / 1800.0 );
    y = sin( *Angle2 * M_PI / 1800.0 );
    t = x * TransMat[0][0] + y * TransMat[0][1];
    y = x * TransMat[1][0] + y * TransMat[1][1];
    x = t;
    *Angle2 = (int) (atan2( y, x ) * 1800.0 / M_PI + 0.5);

    NORMALIZE_ANGLE( *Angle1 );
    NORMALIZE_ANGLE( *Angle2 );
    if( *Angle2 < *Angle1 )
        *Angle2 += 3600;

    if( *Angle2 - *Angle1 > 1800 )
    {                /* Need to swap the two angles. */
        Angle   = (*Angle1);
        *Angle1 = (*Angle2);
        *Angle2 = Angle;

        NORMALIZE_ANGLE( *Angle1 );
        NORMALIZE_ANGLE( *Angle2 );
        if( *Angle2 < *Angle1 )
            *Angle2 += 3600;
        swap = TRUE;
    }

    if( Delta >= 1800 )
    {
        *Angle1 += 1;
        *Angle2 -= 1;
    }

    return swap;
}


/*****************************************************************************
* Routine to display an outline version of given library entry.				 *
* This routine is applied by the PlaceLibItem routine above.			 	 *
*****************************************************************************/
void DrawingLibInGhost( WinEDA_DrawPanel* panel, wxDC* DC,
                        EDA_LibComponentStruct* LibEntry,
                        SCH_COMPONENT* DrawLibItem, int PartX, int PartY,
                        int multi, int convert, int Color, bool DrawPinText )
{
    int DrawMode = g_XorMode;

    DrawLibPartAux( panel, DC, DrawLibItem, LibEntry, wxPoint( PartX, PartY ),
                    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* panel, wxDC* DC,
                            EDA_LibComponentStruct* LibEntry,
                            int PartX, int PartY,
                            LibEDA_BaseStruct* DrawItem, int Multi,
                            int DrawMode, int Color )
{
    int i, x1, y1, x2, y2, t1, t2, orient;
    int CharColor;
    int TransMat[2][2];
    int fill_option;

#undef GETCOLOR
#define GETCOLOR( l ) Color < 0 ? ReturnLayerColor( l ) : Color;

    Multi = 0;  /* unused */
    /* Trace de la structure */
    CharColor = GETCOLOR( LAYER_DEVICE );
    GRSetDrawMode( DC, DrawMode );

    TransMat[0][0] = 1;
    TransMat[0][1] = TransMat[1][0] = 0;
    TransMat[1][1] = -1;

    int LineWidth = MAX( DrawItem->m_Width, g_DrawMinimunLineWidth );

    switch( DrawItem->Type() )
    {
    case COMPONENT_ARC_DRAW_TYPE:
    {
        int         xc, yc, x2, y2;
        LibDrawArc* Arc = (LibDrawArc*) DrawItem;
        t1 = Arc->t1; t2 = Arc->t2;
        bool        swap = MapAngles( &t1, &t2, TransMat );
        xc = PartX + Arc->m_Pos.x;
        yc = PartY - Arc->m_Pos.y;
        x2 = PartX + Arc->m_ArcStart.x;
        y2 = PartY - Arc->m_ArcStart.y;
        x1 = PartX + Arc->m_ArcEnd.x;
        y1 = PartY - Arc->m_ArcEnd.y;

        if( swap )
        {
            EXCHG( x1, x2 ); EXCHG( y1, y2 )
        }
        fill_option = Arc->m_Fill & (~g_PrintFillMask);
        if( (Arc->m_Fill == FILLED_WITH_BG_BODYCOLOR) && !g_IsPrinting )
            GRFilledArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
                        Arc->m_Rayon, CharColor,
                        ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
        else if( Arc->m_Fill == FILLED_SHAPE )
            GRFilledArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
                         Arc->m_Rayon, LineWidth, CharColor, CharColor );
#ifdef DRAW_ARC_WITH_ANGLE
        else
            GRArc( &panel->m_ClipBox, DC, xc, yc, t1, t2,
                   Arc->m_Rayon, CharColor );
#else
        else
            GRArc1( &panel->m_ClipBox, DC, x1, y1, x2, y2,
                    xc, yc, LineWidth, CharColor );
#endif
    }
        break;

    case COMPONENT_CIRCLE_DRAW_TYPE:
    {
        LibDrawCircle* Circle = (LibDrawCircle*) DrawItem;
        x1 = PartX + Circle->m_Pos.x;
        y1 = PartY - Circle->m_Pos.y;
        fill_option = Circle->m_Fill & (~g_PrintFillMask);
        if( (fill_option == FILLED_WITH_BG_BODYCOLOR) && !g_IsPrinting )
            GRFilledCircle( &panel->m_ClipBox, DC, x1, y1,
                           Circle->m_Rayon, LineWidth, CharColor,
                           ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
        else if( fill_option == FILLED_SHAPE )
            GRFilledCircle( &panel->m_ClipBox, DC, x1, y1,
                            Circle->m_Rayon, 0, CharColor, CharColor );
        else
            GRCircle( &panel->m_ClipBox, DC, x1, y1,
                      Circle->m_Rayon, LineWidth, CharColor );
    }
        break;

    case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
    {
        LibDrawText* Text = (LibDrawText*) DrawItem;
        x1 = PartX + Text->m_Pos.x;
        y1 = PartY - Text->m_Pos.y;
        DrawGraphicText( panel, DC, wxPoint( x1, y1 ), CharColor, Text->m_Text,
                         Text->m_Horiz,
                         Text->m_Size,
                         GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, LineWidth );
    }
        break;

    case COMPONENT_RECT_DRAW_TYPE:
    {
        LibDrawSquare* Square = (LibDrawSquare*) DrawItem;
        x1 = PartX + Square->m_Pos.x;
        y1 = PartY - Square->m_Pos.y;
        x2 = PartX + Square->m_End.x;
        y2 = PartY - Square->m_End.y;
        fill_option = Square->m_Fill & (~g_PrintFillMask);
        if( (fill_option == FILLED_WITH_BG_BODYCOLOR) && !g_IsPrinting )
            GRFilledRect( &panel->m_ClipBox, DC, x1, y1, x2, y2,
                         CharColor, LineWidth,
                         ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
        else if( fill_option == FILLED_SHAPE )
            GRFilledRect( &panel->m_ClipBox, DC, x1, y1, x2, y2,
                          CharColor, CharColor );
        else
            GRRect( &panel->m_ClipBox, DC, x1, y1, x2, y2, LineWidth,
                    CharColor );
    }
        break;

    case COMPONENT_PIN_DRAW_TYPE:     /* Trace des Pins */
    {
        LibDrawPin* Pin = (LibDrawPin*) DrawItem;
        x2 = PartX + Pin->m_Pos.x;
        y2 = PartY - Pin->m_Pos.y;
        /* Compute the real pin orientation, i.e. pin orient + component orient */
        orient = Pin->ReturnPinDrawOrient( TransMat );

        /* Dessin de la pin et du symbole special associe */
        if( Pin->m_Attributs & PINNOTDRAW )
            CharColor = DARKGRAY;
        else
            CharColor = -1;

        Pin->DrawPinSymbol( panel, DC, wxPoint( x2, y2 ), orient, DrawMode );
        wxPoint pinpos( x2, y2 );

        Pin->DrawPinTexts( panel, DC, pinpos, orient,
                           LibEntry->m_TextInside,
                           LibEntry->m_DrawPinNum, LibEntry->m_DrawPinName,
                           CharColor, DrawMode );
    }
        break;

    case COMPONENT_POLYLINE_DRAW_TYPE:
    {
        LibDrawPolyline* polyline = (LibDrawPolyline*) DrawItem;
        if( Buf_Poly_Drawings == NULL )
        {
            Buf_Poly_Size     = polyline->n;
            Buf_Poly_Drawings = (int*) MyMalloc( sizeof(int) * 2 * Buf_Poly_Size );
        }
        else if( Buf_Poly_Size < polyline->n )
        {
            Buf_Poly_Size     = polyline->n;
            Buf_Poly_Drawings = (int*) realloc( Buf_Poly_Drawings,
                                                sizeof(int) * 2 * Buf_Poly_Size );
        }
        for( i = 0; i < polyline->n; i++ )
        {
            Buf_Poly_Drawings[i * 2]     = PartX + polyline->PolyList[i * 2];
            Buf_Poly_Drawings[i * 2 + 1] = PartY - polyline->PolyList[i * 2 + 1];
        }

        fill_option = polyline->m_Fill & (~g_PrintFillMask);
        if( (fill_option == FILLED_WITH_BG_BODYCOLOR) && !g_IsPrinting )
            GRPoly( &panel->m_ClipBox, DC, polyline->n,
                   Buf_Poly_Drawings, 1, LineWidth, CharColor,
                   ReturnLayerColor( LAYER_DEVICE_BACKGROUND ) );
        else if( fill_option == FILLED_SHAPE )
            GRPoly( &panel->m_ClipBox, DC, polyline->n,
                    Buf_Poly_Drawings, 1, LineWidth, CharColor, CharColor );
        else
            GRPoly( &panel->m_ClipBox, DC, polyline->n,
                    Buf_Poly_Drawings, 0, LineWidth, CharColor, CharColor );
        break;
    }

    default:
        ;
    }
}