自学教程：C++ GRSetDrawMode函数代码示例

void SCH_BITMAP::Draw( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPoint& aOffset,                       GR_DRAWMODE aDrawMode, COLOR4D aColor ){    wxPoint pos = m_pos + aOffset;    if( aColor == COLOR4D::UNSPECIFIED )    // Use normal drawing function    {        // https://bugs.launchpad.net/kicad/+bug/1529163        // "Moving images in eeschema on OS X uses        //  wrong position and shows image flipped"        //        // Original fix was to only GRSetDrawMode if aColor >= 0, but this made        // moving SCH_BITMAP work poorly on other platforms.#ifndef __WXMAC__        GRSetDrawMode( aDC, aDrawMode );#endif        m_image->DrawBitmap( aPanel, aDC, pos );    }    else    // draws bounding box only (used to move items)    {        GRSetDrawMode( aDC, aDrawMode );        // To draw the rect, pos is the upper left corner position        wxSize size = m_image->GetSize();        pos.x -= size.x / 2;        pos.y -= size.y / 2;        GRRect( aPanel->GetClipBox(), aDC, pos.x, pos.y,                pos.x + size.x, pos.y + size.y, 0, aColor );    }}

static void DrawMovingBlockOutlines(WinEDA_DrawPanel * panel, wxDC * DC,	bool erase )/************************************************************************//* Retrace le contour du block de recherche de structures	L'ensemble du block suit le curseur*/{DrawBlockStruct * PtBlock;DrawPickedStruct *PickedList;BASE_SCREEN * screen = panel->m_Parent->GetScreen();	PtBlock = &panel->GetScreen()->BlockLocate;	GRSetDrawMode(DC, g_XorMode);	/* Effacement ancien cadre */	if( erase && PtBlock->m_BlockDrawStruct)	{		PtBlock->Offset(PtBlock->m_MoveVector);		PtBlock->Draw(panel, DC);		PtBlock->Offset( -PtBlock->m_MoveVector.x, -PtBlock->m_MoveVector.y);		/* Effacement ancien affichage */		if(PtBlock->m_BlockDrawStruct->m_StructType == DRAW_PICK_ITEM_STRUCT_TYPE)		{			PickedList  = (DrawPickedStruct *) PtBlock->m_BlockDrawStruct;			while (PickedList)			{				DrawStructsInGhost(panel, DC, PickedList->m_PickedStruct, PtBlock->m_MoveVector.x, PtBlock->m_MoveVector.y);				PickedList = (DrawPickedStruct *)PickedList->Pnext;			}		}		else DrawStructsInGhost(panel, DC, PtBlock->m_BlockDrawStruct, PtBlock->m_MoveVector.x, PtBlock->m_MoveVector.y);	}	/* 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;	GRSetDrawMode(DC, g_XorMode);	PtBlock->Offset(PtBlock->m_MoveVector);	PtBlock->Draw(panel, DC);	PtBlock->Offset( -PtBlock->m_MoveVector.x, -PtBlock->m_MoveVector.y);	if(PtBlock->m_BlockDrawStruct )	{		if(PtBlock->m_BlockDrawStruct->m_StructType == DRAW_PICK_ITEM_STRUCT_TYPE)		{		PickedList  = (DrawPickedStruct *) PtBlock->m_BlockDrawStruct;		while (PickedList)			{			DrawStructsInGhost(panel, DC, PickedList->m_PickedStruct, PtBlock->m_MoveVector.x, PtBlock->m_MoveVector.y);			PickedList = (DrawPickedStruct *)PickedList->Pnext;			}		}		else DrawStructsInGhost(panel, DC, PtBlock->m_BlockDrawStruct, PtBlock->m_MoveVector.x, PtBlock->m_MoveVector.y);	}}

void WinEDA_LibeditFrame::EditField(wxDC * DC, LibDrawField *Field)/******************************************************************/{wxString Text;int color;wxString title = wxT("Text:");	if( Field == NULL) return;	switch (Field->m_FieldId)	{		case REFERENCE:			title = wxT("Reference:");			color = ReturnLayerColor(LAYER_REFERENCEPART);			break;		case VALUE:			title = wxT("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;	Get_Message(title,Text, this);	Text.Replace( wxT(" ") , wxT("_") );	GRSetDrawMode(DC, g_XorMode);	DrawGraphicText(DrawPanel, DC, wxPoint(Field->m_Pos.x, - Field->m_Pos.y),					color, Field->m_Text,					Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,					Field->m_Size,					Field->m_HJustify, Field->m_VJustify);	if( ! Text.IsEmpty() )	{		SaveCopyInUndoList();		Field->m_Text = Text;	}	else DisplayError(this, _("No new text: no change") );	if( Field->m_Flags == 0 ) GRSetDrawMode(DC, GR_DEFAULT_DRAWMODE);	DrawGraphicText(DrawPanel, DC, wxPoint(Field->m_Pos.x, - Field->m_Pos.y),					color, Field->m_Text,					Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,					Field->m_Size,					Field->m_HJustify, Field->m_VJustify);	m_CurrentScreen->SetModify();	if ( Field->m_FieldId == VALUE ) ReCreateHToolbar();}

/* Draw PCB_TARGET object: 2 segments + 1 circle * The circle radius is half the radius of the target * 2 lines have length the diameter of the target */void PCB_TARGET::Draw( EDA_DRAW_PANEL* panel, wxDC* DC, GR_DRAWMODE mode_color,                       const wxPoint& offset ){    int radius, ox, oy, width;    int dx1, dx2, dy1, dy2;    ox = m_Pos.x + offset.x;    oy = m_Pos.y + offset.y;    BOARD * brd =  GetBoard( );    if( brd->IsLayerVisible( m_Layer ) == false )        return;    auto frame = static_cast<PCB_EDIT_FRAME*> ( panel->GetParent() );    auto gcolor = frame->Settings().Colors().GetLayerColor( m_Layer );    GRSetDrawMode( DC, mode_color );    auto displ_opts = (PCB_DISPLAY_OPTIONS*)( panel->GetDisplayOptions() );    bool filled = displ_opts ? displ_opts->m_DisplayDrawItemsFill : FILLED;    width   = m_Width;    radius = m_Size / 3;    if( GetShape() )   // shape X        radius = m_Size / 2;    if( filled )        GRCircle( panel->GetClipBox(), DC, ox, oy, radius, width, gcolor );    else    {        GRCircle( panel->GetClipBox(), DC, ox, oy, radius + (width / 2), gcolor );        GRCircle( panel->GetClipBox(), DC, ox, oy, radius - (width / 2), gcolor );    }    radius = m_Size / 2;    dx1   = radius;    dy1   = 0;    dx2   = 0;    dy2   = radius;    if( GetShape() )   // shape X    {        dx1 = dy1 = radius;        dx2 = dx1;        dy2 = -dy1;    }    if( filled )    {        GRLine( panel->GetClipBox(), DC, ox - dx1, oy - dy1, ox + dx1, oy + dy1, width, gcolor );        GRLine( panel->GetClipBox(), DC, ox - dx2, oy - dy2, ox + dx2, oy + dy2, width, gcolor );    }    else    {        GRCSegm( panel->GetClipBox(), DC, ox - dx1, oy - dy1, ox + dx1, oy + dy1, width, gcolor );        GRCSegm( panel->GetClipBox(), DC, ox - dx2, oy - dy2, ox + dx2, oy + dy2, width, gcolor );    }}

void EDA_DRAW_PANEL::DrawBackGround( wxDC* DC ){    GRSetDrawMode( DC, GR_COPY );    if( GetParent()->IsGridVisible() )        DrawGrid( DC );    // Draw axis    if( GetParent()->GetShowAxis() )    {        COLOR4D axis_color = COLOR4D( BLUE );        wxSize  pageSize = GetParent()->GetPageSizeIU();        // Draw the Y axis        GRLine( &m_ClipBox, DC, 0, -pageSize.y, 0, pageSize.y, 0, axis_color );        // Draw the X axis        GRLine( &m_ClipBox, DC, -pageSize.x, 0, pageSize.x, 0, 0, axis_color );    }    if( GetParent()->GetShowOriginAxis() )        DrawAuxiliaryAxis( DC, GR_COPY );    if( GetParent()->GetShowGridAxis() )        DrawGridAxis( DC, GR_COPY, GetParent()->GetGridOrigin() );}

void SCH_BUS_ENTRY_BASE::Draw( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPoint& aOffset,                          GR_DRAWMODE aDrawMode, COLOR4D aColor ){    COLOR4D color;    EDA_RECT* clipbox = aPanel->GetClipBox();    if( aColor != COLOR4D::UNSPECIFIED )        color = aColor;    else        color = GetLayerColor( GetState( BRIGHTENED ) ? LAYER_BRIGHTENED : m_Layer );    GRSetDrawMode( aDC, aDrawMode );    GRLine( clipbox, aDC, m_pos.x + aOffset.x, m_pos.y + aOffset.y,            m_End().x + aOffset.x, m_End().y + aOffset.y, GetPenSize(), color );    // Draw pin targets if part is being dragged    bool dragging = aPanel->GetScreen()->GetCurItem() == this && aPanel->IsMouseCaptured();    if( m_isDanglingStart || dragging )    {        GRCircle( clipbox, aDC, m_pos.x + aOffset.x, m_pos.y + aOffset.y,                TARGET_BUSENTRY_RADIUS, 0, color );    }    if( m_isDanglingEnd || dragging )    {        GRCircle( clipbox, aDC, m_End().x + aOffset.x, m_End().y + aOffset.y,                TARGET_BUSENTRY_RADIUS, 0, color );    }}

static void Polyline_in_Ghost(WinEDA_DrawPanel * panel, wxDC * DC, bool erase)/*****************************************************************************//*  Dessin du du Polyline Fantome lors des deplacements du curseur*/{DrawPolylineStruct * NewPoly =		(DrawPolylineStruct *)panel->m_Parent->GetScreen()->m_CurrentItem;int color;wxPoint endpos;	endpos = panel->m_Parent->GetScreen()->m_Curseur;	color = ReturnLayerColor(NewPoly->m_Layer);	GRSetDrawMode(DC, XOR_MODE);	if( g_HVLines )		{		/* Coerce the line to vertical or horizontal one: */		if (ABS(endpos.x - NewPoly->m_Points[NewPoly->m_NumOfPoints * 2 - 2]) <			 ABS(endpos.y - NewPoly->m_Points[NewPoly->m_NumOfPoints * 2 - 1]))			endpos.x = NewPoly->m_Points[NewPoly->m_NumOfPoints * 2 - 2];		else			endpos.y = NewPoly->m_Points[NewPoly->m_NumOfPoints * 2 - 1];		}	NewPoly->m_NumOfPoints++;	if( erase )		RedrawOneStruct(panel,DC, NewPoly, XOR_MODE, color);	NewPoly->m_Points[NewPoly->m_NumOfPoints * 2 - 2] = endpos.x;	NewPoly->m_Points[NewPoly->m_NumOfPoints * 2 - 1] = endpos.y;	RedrawOneStruct(panel,DC, NewPoly, XOR_MODE, color);	NewPoly->m_NumOfPoints--;}

void WinEDA_BasePcbFrame::trace_ratsnest_pad(wxDC * DC)/*******************************************************//* affiche le "chevelu" d'un pad lors des trace de segments de piste*/{int * pt_coord;int ii;int refX, refY;	if((m_Pcb->m_Status_Pcb & LISTE_CHEVELU_OK) == 0) return;	if( nb_local_chevelu == 0 ) return;	if ( local_liste_chevelu == NULL ) return;	pt_coord = (int*) local_liste_chevelu;	refX = *pt_coord; pt_coord++;	refY = *pt_coord; pt_coord++;	GRSetDrawMode(DC, GR_XOR);	for( ii = 0; ii < nb_local_chevelu; ii++)		{		if ( ii >= g_MaxLinksShowed ) break;		GRLine(&DrawPanel->m_ClipBox, DC, refX, refY, *pt_coord, *(pt_coord+1), YELLOW);		pt_coord += 2;		}}

void EDA_DRAW_PANEL::DrawGridAxis( wxDC* aDC, GR_DRAWMODE aDrawMode, const wxPoint& aGridOrigin ){    if( !GetParent()->GetShowGridAxis() || ( !aGridOrigin.x && !aGridOrigin.y ) )        return;    COLOR4D color = GetParent()->GetGridColor();    GRSetDrawMode( aDC, aDrawMode );#if DRAW_AXIS_AS_LINES    wxSize      pageSize = GetParent()->GetPageSizeIU();    // Draw the Y axis    GRLine( &m_ClipBox, aDC, aGridOrigin.x, -pageSize.y,            aGridOrigin.x, pageSize.y, 0, color );    // Draw the X axis    GRLine( &m_ClipBox, aDC, -pageSize.x, aGridOrigin.y,            pageSize.x, aGridOrigin.y, 0, color );#else    int radius = aDC->DeviceToLogicalXRel( AXIS_SIZE_IN_PIXELS );    int linewidth = aDC->DeviceToLogicalXRel( 1 );    GRSetColorPen( aDC, GetParent()->GetGridColor(), linewidth );    GRLine( &m_ClipBox, aDC, aGridOrigin.x-radius, aGridOrigin.y-radius,            aGridOrigin.x+radius, aGridOrigin.y+radius, 0, color );    // Draw the X shape    GRLine( &m_ClipBox, aDC, aGridOrigin.x+radius, aGridOrigin.y-radius,            aGridOrigin.x-radius, aGridOrigin.y+radius, 0, color );    GRCircle( &m_ClipBox, aDC, aGridOrigin, radius, linewidth, color );#endif}

void EDA_DRAW_PANEL::DrawAuxiliaryAxis( wxDC* aDC, GR_DRAWMODE aDrawMode ){    wxPoint origin = GetParent()->GetAuxOrigin();    if( origin == wxPoint( 0, 0 ) )        return;    EDA_COLOR_T color = DARKRED;    wxSize  pageSize = GetParent()->GetPageSizeIU();    GRSetDrawMode( aDC, aDrawMode );    // Draw the Y axis    GRDashedLine( &m_ClipBox, aDC,                  origin.x,                  -pageSize.y,                  origin.x,                  pageSize.y,                  0, color );    // Draw the X axis    GRDashedLine( &m_ClipBox, aDC,                  -pageSize.x,                  origin.y,                  pageSize.x,                  origin.y,                  0, color );}

void FOOTPRINT_EDIT_FRAME::RedrawActiveWindow( wxDC* DC, bool EraseBg ){    PCB_SCREEN* screen = GetScreen();    if( !GetBoard() || !screen )        return;    GRSetDrawMode( DC, GR_COPY );    m_canvas->DrawBackGround( DC );    DrawWorkSheet( DC, screen, 0, IU_PER_MILS, wxEmptyString );    // Redraw the footprints    for( MODULE* module = GetBoard()->m_Modules; module; module = module->Next() )        module->Draw( m_canvas, DC, GR_OR | GR_ALLOW_HIGHCONTRAST );#ifdef USE_WX_OVERLAY    if( IsShown() )    {        m_overlay.Reset();        wxDCOverlay overlaydc( m_overlay, (wxWindowDC*) DC );        overlaydc.Clear();    }#endif    if( m_canvas->IsMouseCaptured() )        m_canvas->CallMouseCapture( DC, wxDefaultPosition, false );    // Redraw the cursor    m_canvas->DrawCrossHair( DC );}

void SCH_TEXT::Draw( EDA_DRAW_PANEL* panel, wxDC* DC, const wxPoint& aOffset,                     GR_DRAWMODE DrawMode, EDA_COLOR_T Color ){    EDA_COLOR_T color;    int         linewidth = ( m_Thickness == 0 ) ? GetDefaultLineThickness() : m_Thickness;    linewidth = Clamp_Text_PenSize( linewidth, m_Size, m_Bold );    if( Color >= 0 )        color = Color;    else        color = ReturnLayerColor( m_Layer );    GRSetDrawMode( DC, DrawMode );    wxPoint text_offset = aOffset + GetSchematicTextOffset();    EXCHG( linewidth, m_Thickness );            // Set the minimum width    EDA_TEXT::Draw( panel, DC, text_offset, color, DrawMode, FILLED, UNSPECIFIED_COLOR );    EXCHG( linewidth, m_Thickness );            // set initial value    if( m_isDangling )        DrawDanglingSymbol( panel, DC, m_Pos + aOffset, color );    // Enable these line to draw the bounding box (debug tests purposes only)#if 0    {        EDA_RECT BoundaryBox = GetBoundingBox();        GRRect( panel->GetClipBox(), DC, BoundaryBox, 0, BROWN );    }#endif}

void BASE_SCREEN::Trace_Curseur(WinEDA_DrawPanel * panel, wxDC * DC)/*******************************************************************//* Trace Le curseur sur la zone PCB , se deplacant sur la grille*/{int color = WHITE;		GRSetDrawMode(DC, GR_XOR);	if( g_CursorShape == 1 )	/* Trace d'un reticule */		{		int dx = panel->m_ClipBox.GetWidth() * GetZoom();		int dy = panel->m_ClipBox.GetHeight() * GetZoom();		GRLine(&panel->m_ClipBox, DC, m_Curseur.x - dx, m_Curseur.y,							m_Curseur.x + dx, m_Curseur.y, color); // axe Y		GRLine(&panel->m_ClipBox, DC, m_Curseur.x, m_Curseur.y - dx,				m_Curseur.x, m_Curseur.y + dy, color);  // axe X		}	else		{		int len = CURSOR_SIZE * GetZoom();		GRLine(&panel->m_ClipBox, DC, m_Curseur.x - len, m_Curseur.y,				m_Curseur.x + len, m_Curseur.y, color);		GRLine(&panel->m_ClipBox, DC, m_Curseur.x, m_Curseur.y - len,				m_Curseur.x, m_Curseur.y + len, color);		}}

void DrawAndSizingBlockOutlines(WinEDA_DrawPanel * panel, wxDC * DC, bool erase )/********************************************************************************//* Redraw the outlines of the block which shows the search area for block commands	The first point of the rectangle showing the area is initialised	by InitBlockLocateDatas().	The other point of the rectangle is the mouse cursor */{    DrawBlockStruct * PtBlock;    PtBlock = &panel->GetScreen()->BlockLocate;    PtBlock->m_MoveVector = wxPoint(0,0);    GRSetDrawMode(DC, g_XorMode);    /* Effacement ancien cadre */    if( erase ) PtBlock->Draw(panel, DC);    PtBlock->m_BlockLastCursorPosition = panel->GetScreen()->m_Curseur;    PtBlock->SetEnd(panel->GetScreen()->m_Curseur);    PtBlock->Draw(panel, DC);    if ( PtBlock->m_State == STATE_BLOCK_INIT )    {        if ( PtBlock->GetWidth() || PtBlock->GetHeight() )            /* 2ieme point existant: le rectangle n'est pas de surface nulle */            PtBlock->m_State = STATE_BLOCK_END;    }}

void WinEDA_PcbFrame::RedrawActiveWindow(wxDC * DC, bool EraseBg)/****************************************************************//* Trace le PCB, et les elements complementaires ( axes, grille .. ) pour l'ecran actif et ses sous ecran*/{PCB_SCREEN * Screen = GetScreen();	if ( ! m_Pcb || ! Screen ) return;	ActiveScreen = GetScreen();	GRSetDrawMode(DC, GR_COPY);	if ( EraseBg ) DrawPanel->EraseScreen(DC);	DrawPanel->DrawBackGround(DC);	Trace_Pcb(DC, GR_OR);	TraceWorkSheet(DC, GetScreen());	Affiche_Status_Box();	/* Reaffichage des curseurs */	for( Screen = GetScreen(); Screen != NULL; Screen = Screen->Next() )	{		if( m_CurrentScreen->ManageCurseur )			m_CurrentScreen->ManageCurseur(DrawPanel, DC, FALSE);		Screen->Trace_Curseur(DrawPanel, DC);	}}

void WinEDA_LibeditFrame::RotateField(wxDC * DC, LibDrawField *Field)/********************************************************************//* 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*/{int color;	if( Field == NULL) return;	m_CurrentScreen->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  ) color = DARKGRAY;	GRSetDrawMode(DC, g_XorMode);	DrawGraphicText(DrawPanel, DC, wxPoint(Field->m_Pos.x, - Field->m_Pos.y),					color, Field->m_Text,					Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,					Field->m_Size,					Field->m_HJustify, Field->m_VJustify);	if( Field->m_Orient) Field->m_Orient = 0;	else Field->m_Orient = 1;	if( Field->m_Flags == 0 ) GRSetDrawMode(DC, GR_DEFAULT_DRAWMODE);	DrawGraphicText(DrawPanel, DC, wxPoint(Field->m_Pos.x, - Field->m_Pos.y),					color, Field->m_Text,					Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,					Field->m_Size,					Field->m_HJustify, Field->m_VJustify);}

void WinEDA_DrawPanel::EraseScreen(wxDC * DC)/*********************************************/{	GRSetDrawMode(DC, GR_COPY);	GRSFilledRect(&m_ClipBox, DC, m_ClipBox.GetX(), m_ClipBox.GetY(),				m_ClipBox.GetRight(), m_ClipBox.GetBottom(),				g_DrawBgColor, g_DrawBgColor);}

void SEGZONE::Draw( EDA_DRAW_PANEL* panel, wxDC* aDC, GR_DRAWMODE aDrawMode,                    const wxPoint& aOffset ){    DISPLAY_OPTIONS* displ_opts = (DISPLAY_OPTIONS*)panel->GetDisplayOptions();    if( displ_opts->m_DisplayZonesMode != 0 )        return;    BOARD * brd = GetBoard( );    EDA_COLOR_T color = brd->GetLayerColor(m_Layer);    if( brd->IsLayerVisible( m_Layer ) == false && !( aDrawMode & GR_HIGHLIGHT ) )        return;#ifdef USE_WX_OVERLAY    // If dragged not draw in OnPaint otherwise remains impressed in wxOverlay    if( (m_Flags & IS_DRAGGED) && aDC->IsKindOf(wxCLASSINFO(wxPaintDC)))      return;#endif    if( ( aDrawMode & GR_ALLOW_HIGHCONTRAST ) && displ_opts->m_ContrastModeDisplay )    {        LAYER_ID curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;        if( !IsOnLayer( curr_layer ) )            ColorTurnToDarkDarkGray( &color );    }    if( aDrawMode & GR_HIGHLIGHT )        ColorChangeHighlightFlag( &color, !(aDrawMode & GR_AND) );    ColorApplyHighlightFlag( &color );    SetAlpha( &color, 150 );    GRSetDrawMode( aDC, aDrawMode );    int l_trace = m_Width / 2;    if( aDC->LogicalToDeviceXRel( l_trace ) <= MIN_DRAW_WIDTH )    {        GRLine( panel->GetClipBox(), aDC, m_Start + aOffset, m_End + aOffset, 0, color );        return;    }    if( !displ_opts->m_DisplayPcbTrackFill || GetState( FORCE_SKETCH ) )    {        GRCSegm( panel->GetClipBox(), aDC, m_Start + aOffset, m_End + aOffset, m_Width, color );    }    else    {        GRFillCSegm( panel->GetClipBox(), aDC, m_Start.x + aOffset.x,                     m_Start.y + aOffset.y,                     m_End.x + aOffset.x, m_End.y + aOffset.y, m_Width, color );    }    // No clearance or netnames for zones}

void SEGZONE::Draw( EDA_DRAW_PANEL* panel, wxDC* aDC, GR_DRAWMODE aDrawMode,                    const wxPoint& aOffset ){    auto displ_opts = (PCB_DISPLAY_OPTIONS*)( panel->GetDisplayOptions() );    if( displ_opts->m_DisplayZonesMode != 0 )        return;    BOARD* brd = GetBoard();    auto frame = static_cast<PCB_BASE_FRAME*> ( panel->GetParent() );    auto color = frame->Settings().Colors().GetLayerColor( m_Layer );    if( brd->IsLayerVisible( m_Layer ) == false && !( aDrawMode & GR_HIGHLIGHT ) )        return;#ifdef USE_WX_OVERLAY    // If dragged not draw in OnPaint otherwise remains impressed in wxOverlay    if( (m_Flags & IS_DRAGGED) && aDC->IsKindOf(wxCLASSINFO(wxPaintDC)))      return;#endif    if( ( aDrawMode & GR_ALLOW_HIGHCONTRAST ) && displ_opts->m_ContrastModeDisplay )    {        PCB_LAYER_ID curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;        if( !IsOnLayer( curr_layer ) )            color = COLOR4D( DARKDARKGRAY );    }    if( ( aDrawMode & GR_HIGHLIGHT ) && !( aDrawMode & GR_AND ) )        color.SetToLegacyHighlightColor();    color.a = 0.588;    GRSetDrawMode( aDC, aDrawMode );    // Draw track as line if width <= 1pixel:    if( aDC->LogicalToDeviceXRel( m_Width ) <= 1 )    {        GRLine( panel->GetClipBox(), aDC, m_Start + aOffset, m_End + aOffset, m_Width, color );        return;    }    if( !displ_opts->m_DisplayPcbTrackFill || GetState( FORCE_SKETCH ) )    {        GRCSegm( panel->GetClipBox(), aDC, m_Start + aOffset, m_End + aOffset, m_Width, color );    }    else    {        GRFillCSegm( panel->GetClipBox(), aDC, m_Start.x + aOffset.x,                     m_Start.y + aOffset.y,                     m_End.x + aOffset.x, m_End.y + aOffset.y, m_Width, color );    }    // No clearance or netnames for zones}

/* DEBUG Function: displays the routing matrix */void DisplayRoutingMatrix( EDA_DRAW_PANEL* panel, wxDC* DC ){    int dcell0;    EDA_COLOR_T color;    int maxi = 600 / RoutingMatrix.m_Ncols;    maxi = ( maxi * 3 ) / 4;    if( !maxi )        maxi = 1;    GRSetDrawMode( DC, GR_COPY );    for( int col = 0; col < RoutingMatrix.m_Ncols; col++ )    {        for( int row = 0; row < RoutingMatrix.m_Nrows; row++ )        {            color  = BLACK;            dcell0 = RoutingMatrix.GetCell( row, col, BOTTOM );            if( dcell0 & HOLE )                color = GREEN;#if 0            int dcell1 = 0;            if( RoutingMatrix.m_RoutingLayersCount )                dcell1 = GetCell( row, col, TOP );            if( dcell1 & HOLE )                color = RED;            dcell0 |= dcell1;#endif            if( !color && ( dcell0 & VIA_IMPOSSIBLE ) )                color = BLUE;            if( dcell0 & CELL_is_EDGE )                color = YELLOW;            else if( dcell0 & CELL_is_ZONE )                color = YELLOW;            #define DRAW_OFFSET_X -20            #define DRAW_OFFSET_Y 20//            if( color )            {                for( int i = 0; i < maxi; i++ )                    for( int j = 0; j < maxi; j++ )                        GRPutPixel( panel->GetClipBox(), DC,                                    ( col * maxi ) + i + DRAW_OFFSET_X,                                    ( row * maxi ) + j + DRAW_OFFSET_Y, color );            }        }    }}

void LIB_POLYLINE::drawGraphic( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPoint& aOffset,                                EDA_COLOR_T aColor, GR_DRAWMODE aDrawMode, void* aData,                                const TRANSFORM& aTransform ){    wxPoint  pos1;    EDA_COLOR_T color = GetLayerColor( LAYER_DEVICE );    wxPoint* buffer = NULL;    if( aColor < 0 )                // Used normal color or selected color    {        if( IsSelected() )            color = GetItemSelectedColor();    }    else    {        color = aColor;    }    buffer = new wxPoint[ m_PolyPoints.size() ];    for( unsigned ii = 0; ii < m_PolyPoints.size(); ii++ )    {        buffer[ii] = aTransform.TransformCoordinate( m_PolyPoints[ii] ) + aOffset;    }    FILL_T fill = aData ? NO_FILL : m_Fill;    if( aColor >= 0 )        fill = NO_FILL;    GRSetDrawMode( aDC, aDrawMode );    EDA_RECT* const clipbox  = aPanel? aPanel->GetClipBox() : NULL;    if( fill == FILLED_WITH_BG_BODYCOLOR )        GRPoly( clipbox, aDC, m_PolyPoints.size(), buffer, 1, GetPenSize(),                (m_Flags & IS_MOVED) ? color : GetLayerColor( LAYER_DEVICE_BACKGROUND ),                GetLayerColor( LAYER_DEVICE_BACKGROUND ) );    else if( fill == FILLED_SHAPE  )        GRPoly( clipbox, aDC, m_PolyPoints.size(), buffer, 1, GetPenSize(),                color, color );    else        GRPoly( clipbox, aDC, m_PolyPoints.size(), buffer, 0, GetPenSize(),                color, color );    delete[] buffer;    /* Set to one (1) to draw bounding box around polyline to validate     * bounding box calculation. */#if 0    EDA_RECT bBox = GetBoundingBox();    bBox.RevertYAxis();    bBox = aTransform.TransformCoordinate( bBox );    bBox.Move( aOffset );    GRRect( clipbox, aDC, bBox, 0, LIGHTMAGENTA );#endif}

void LIB_FIELD::drawGraphic( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPoint& aOffset,                             EDA_COLOR_T aColor, GR_DRAWMODE aDrawMode, void* aData,                             const TRANSFORM& aTransform ){    wxPoint  text_pos;    int      color;    int      linewidth = GetPenSize();    if( m_Bold )        linewidth = GetPenSizeForBold( m_Size.x );    else        linewidth = Clamp_Text_PenSize( linewidth, m_Size, m_Bold );    if( ( m_Attributs & TEXT_NO_VISIBLE ) && ( aColor < 0 ) )    {        color = GetInvisibleItemColor();    }    else if( IsSelected() && ( aColor < 0 ) )    {        color = GetItemSelectedColor();    }    else    {        color = aColor;    }    if( color < 0 )        color = GetDefaultColor();    text_pos = aTransform.TransformCoordinate( m_Pos ) + aOffset;    wxString text;    if( aData )        text = *(wxString*)aData;    else        text = m_Text;    GRSetDrawMode( aDC, aDrawMode );    EDA_RECT* clipbox = aPanel? aPanel->GetClipBox() : NULL;    DrawGraphicText( clipbox, aDC, text_pos, (EDA_COLOR_T) color, text, m_Orient, m_Size,                     m_HJustify, m_VJustify, linewidth, m_Italic, m_Bold );    /* Set to one (1) to draw bounding box around field text to validate     * bounding box calculation. */#if 0    EDA_RECT bBox = GetBoundingBox();    EDA_RECT grBox;    grBox.SetOrigin( aTransform.TransformCoordinate( bBox.GetOrigin() ) );    grBox.SetEnd( aTransform.TransformCoordinate( bBox.GetEnd() ) );    grBox.Move( aOffset );    GRRect( clipbox, aDC, grBox, 0, LIGHTMAGENTA );#endif}

void DIMENSION::Draw( EDA_DRAW_PANEL* panel, wxDC* DC, GR_DRAWMODE mode_color,                      const wxPoint& offset ){    EDA_COLOR_T gcolor;    BOARD*      brd = GetBoard();    if( brd->IsLayerVisible( m_Layer ) == false )        return;    m_Text.Draw( panel, DC, mode_color, offset );    gcolor = brd->GetLayerColor( m_Layer );    GRSetDrawMode( DC, mode_color );    DISPLAY_OPTIONS* displ_opts = (DISPLAY_OPTIONS*)panel->GetDisplayOptions();    bool filled = displ_opts ? displ_opts->m_DisplayDrawItemsFill : FILLED;    int width   = m_Width;    if( filled )    {        GRLine( panel->GetClipBox(), DC, m_crossBarO + offset,                m_crossBarF + offset, width, gcolor );        GRLine( panel->GetClipBox(), DC, m_featureLineGO + offset,                m_featureLineGF + offset, width, gcolor );        GRLine( panel->GetClipBox(), DC, m_featureLineDO + offset,                m_featureLineDF + offset, width, gcolor );        GRLine( panel->GetClipBox(), DC, m_crossBarF + offset,                m_arrowD1F + offset, width, gcolor );        GRLine( panel->GetClipBox(), DC, m_crossBarF + offset,                m_arrowD2F + offset, width, gcolor );        GRLine( panel->GetClipBox(), DC, m_crossBarO + offset,                m_arrowG1F + offset, width, gcolor );        GRLine( panel->GetClipBox(), DC, m_crossBarO + offset,                m_arrowG2F + offset, width, gcolor );    }    else    {        GRCSegm( panel->GetClipBox(), DC, m_crossBarO + offset,                 m_crossBarF + offset, width, gcolor );        GRCSegm( panel->GetClipBox(), DC, m_featureLineGO + offset,                 m_featureLineGF + offset, width, gcolor );        GRCSegm( panel->GetClipBox(), DC, m_featureLineDO + offset,                 m_featureLineDF + offset, width, gcolor );        GRCSegm( panel->GetClipBox(), DC, m_crossBarF + offset,                 m_arrowD1F + offset, width, gcolor );        GRCSegm( panel->GetClipBox(), DC, m_crossBarF + offset,                 m_arrowD2F + offset, width, gcolor );        GRCSegm( panel->GetClipBox(), DC, m_crossBarO + offset,                 m_arrowG1F + offset, width, gcolor );        GRCSegm( panel->GetClipBox(), DC, m_crossBarO + offset,                 m_arrowG2F + offset, width, gcolor );    }}

void MODULE::DrawAncre( EDA_DRAW_PANEL* panel, wxDC* DC, const wxPoint& offset,                        int dim_ancre, GR_DRAWMODE draw_mode ){    GRSetDrawMode( DC, draw_mode );    if( GetBoard()->IsElementVisible( ANCHOR_VISIBLE ) )    {        GRDrawAnchor( panel->GetClipBox(), DC, m_Pos.x, m_Pos.y,                      dim_ancre,                      g_ColorsSettings.GetItemColor( ANCHOR_VISIBLE ) );    }}

/** * Function Draw * Draws a line (a ratsnest) from the starting pad to the ending pad */void RATSNEST_ITEM::Draw( EDA_DRAW_PANEL* panel,                          wxDC*           DC,                          GR_DRAWMODE     aDrawMode,                          const wxPoint&  aOffset ){    GRSetDrawMode( DC, aDrawMode );    EDA_COLOR_T color = g_ColorsSettings.GetItemColor(RATSNEST_VISIBLE);    GRLine( panel->GetClipBox(), DC,            m_PadStart->GetPosition() - aOffset,            m_PadEnd->GetPosition() - aOffset, 0, color );}

void LIB_RECTANGLE::drawGraphic( EDA_DRAW_PANEL* aPanel, wxDC* aDC,                                 const wxPoint& aOffset, EDA_COLOR_T aColor, GR_DRAWMODE aDrawMode,                                 void* aData, const TRANSFORM& aTransform ){    wxPoint pos1, pos2;    EDA_COLOR_T color = GetLayerColor( LAYER_DEVICE );    if( aColor < 0 )       // Used normal color or selected color    {        if( IsSelected() )            color = GetItemSelectedColor();    }    else    {        color = aColor;    }    pos1 = aTransform.TransformCoordinate( m_Pos ) + aOffset;    pos2 = aTransform.TransformCoordinate( m_End ) + aOffset;    FILL_T fill = aData ? NO_FILL : m_Fill;    if( aColor >= 0 )        fill = NO_FILL;    GRSetDrawMode( aDC, aDrawMode );    EDA_RECT* const clipbox  = aPanel? aPanel->GetClipBox() : NULL;    if( fill == FILLED_WITH_BG_BODYCOLOR && !aData )        GRFilledRect( clipbox, aDC, pos1.x, pos1.y, pos2.x, pos2.y, GetPenSize( ),                      (m_Flags & IS_MOVED) ? color : GetLayerColor( LAYER_DEVICE_BACKGROUND ),                      GetLayerColor( LAYER_DEVICE_BACKGROUND ) );    else if( m_Fill == FILLED_SHAPE  && !aData )        GRFilledRect( clipbox, aDC, pos1.x, pos1.y, pos2.x, pos2.y,                      GetPenSize(), color, color );    else        GRRect( clipbox, aDC, pos1.x, pos1.y, pos2.x, pos2.y, GetPenSize(), color );    /* Set to one (1) to draw bounding box around rectangle to validate     * bounding box calculation. */#if 0    EDA_RECT bBox = GetBoundingBox();    bBox.RevertYAxis();    bBox = aTransform.TransformCoordinate( bBox );    bBox.Move( aOffset );    GRRect( clipbox, aDC, bBox, 0, LIGHTMAGENTA );#endif}

/* Draws a line from the TEXTE_MODULE origin to parent MODULE origin.*/void TEXTE_MODULE::DrawUmbilical( EDA_DRAW_PANEL* aPanel,                                  wxDC*           aDC,                                  GR_DRAWMODE     aDrawMode,                                  const wxPoint&  aOffset ){    MODULE* parent = (MODULE*) GetParent();    if( !parent )        return;    GRSetDrawMode( aDC, GR_XOR );    GRLine( aPanel->GetClipBox(), aDC,            parent->GetPosition(), GetTextPosition() + aOffset,            0, UMBILICAL_COLOR);}