kicad/share/drawframe.cpp

	/******************************************************************/
	/* drawframe.cpp - fonctions des classes du type WinEDA_DrawFrame */
	/******************************************************************/

#ifdef __GNUG__
#pragma implementation
#endif

#include "fctsys.h"

#include "common.h"

#ifdef PCBNEW
#include "pcbnew.h"
#endif

#ifdef EESCHEMA
#include "program.h"
#include "libcmp.h"
#include "general.h"
#endif

#ifdef CVPCB
#include "pcbnew.h"
#include "cvpcb.h"
#endif

#include <wx/fontdlg.h>

#include "bitmaps.h"

#include "protos.h"

#include "id.h"


	/*******************************************************/
	/* Constructeur de WinEDA_DrawFrame: la fenetre generale */
	/*******************************************************/

WinEDA_DrawFrame::WinEDA_DrawFrame( wxWindow * father, int idtype,
						WinEDA_App *parent, const wxString & title,
						const wxPoint& pos, const wxSize& size):
		WinEDA_BasicFrame(father, idtype, parent, title, pos, size)
{
wxSize minsize;

	m_VToolBar = NULL;
	m_AuxVToolBar = NULL;
	m_OptionsToolBar = NULL;
	m_AuxiliaryToolBar = NULL;
	m_SelGridBox = NULL;
	m_SelZoomBox = NULL;
	m_ZoomMaxValue = 128;

	DrawPanel = NULL;
	MsgPanel = NULL;
	m_CurrentScreen = NULL;
	m_MenuBar = NULL;		// menu du haut d'ecran
	m_ID_current_state = 0;
	m_HTOOL_current_state = 0;
	m_Draw_Axis = FALSE;			// TRUE pour avoir les axes dessines
	m_Draw_Grid = FALSE;			// TRUE pour avoir la axes dessinee
	m_Draw_Sheet_Ref = FALSE;		// TRUE pour avoir le cartouche dessin<69>
	m_Print_Sheet_Ref = TRUE;		// TRUE pour avoir le cartouche imprim<69>
	m_Draw_Auxiliary_Axis = FALSE;	// TRUE pour avoir les axes auxiliares dessines
	m_UnitType = INTERNAL_UNIT_TYPE;		// Internal unit = inch
	// nombre d'unites internes pour 1 pouce
	// = 1000 pour schema, = 10000 pour PCB
	m_InternalUnits = EESCHEMA_INTERNAL_UNIT;
	if( (m_Ident == PCB_FRAME) || (m_Ident == GERBER_FRAME) ||
		 (m_Ident == CVPCB_DISPLAY_FRAME) ||
		 (m_Ident == MODULE_EDITOR_FRAME)
		)
		m_InternalUnits = PCB_INTERNAL_UNIT ;

	minsize.x = 470;
	minsize.y = 350 + m_MsgFrameHeight;
	SetSizeHints( minsize.x, minsize.y, -1,-1, -1,-1);

	/* Verification des parametres de creation */
	if ( (size.x < minsize.x) || (size.y < minsize.y) )
		SetSize(0,0, minsize.x, minsize.y);

	// Creation de la ligne de status
int dims[6] = { -1, 60, 130, 130, 40, 100};
	CreateStatusBar(6);
	SetStatusWidths(6,dims);

	// Create child subwindows.
	GetClientSize(&m_FrameSize.x, &m_FrameSize.y);	/* dimx, dimy = dimensions utiles de la
								zone utilisateur de la fenetre principale */
	m_FramePos.x = m_FramePos.y = 0;
	m_FrameSize.y -= m_MsgFrameHeight;

	if ( m_Ident != DISPLAY3D_FRAME)
	{
		DrawPanel = new WinEDA_DrawPanel(this, -1, wxPoint(0, 0), m_FrameSize);
		MsgPanel = new WinEDA_MsgPanel(this, -1, wxPoint(0, m_FrameSize.y),
							wxSize(m_FrameSize.x, m_MsgFrameHeight));
		MsgPanel->SetBackgroundColour(wxColour(ColorRefs[LIGHTGRAY].m_Red,
						ColorRefs[LIGHTGRAY].m_Green,
						ColorRefs[LIGHTGRAY].m_Blue ));
	}

}

/****************************************/
WinEDA_DrawFrame::~WinEDA_DrawFrame(void)
/****************************************/
{
	if ( DrawPanel )	// for WinEDA3D_DrawFrame DrawPanel == NULL !
		m_Parent->m_EDA_Config->Write( wxT("AutoPAN"), DrawPanel->m_AutoPAN_Enable);
}


/****************************************************************/
void WinEDA_DrawFrame::AddFontSelectionMenu(wxMenu * main_menu)
/*****************************************************************/
/* create the submenu for fonte selection and setup fonte size
*/
{
wxMenu * fontmenu = new wxMenu();
	ADD_MENUITEM(fontmenu, ID_PREFERENCES_FONT_DIALOG, _("font for dialog boxes"),
		fonts_xpm );
	ADD_MENUITEM(fontmenu, ID_PREFERENCES_FONT_INFOSCREEN, _("font for info display"),
		fonts_xpm );
	ADD_MENUITEM(fontmenu, ID_PREFERENCES_FONT_STATUS, _("font for Status Line"),
		fonts_xpm );
	ADD_MENUITEM_WITH_HELP_AND_SUBMENU(main_menu, fontmenu,
		ID_PREFERENCES_FONT, _("&Font selection"),
		_("Choose font type and size for dialogs, infos and status box"),
		fonts_xpm);
}

/********************************************************************/
void WinEDA_DrawFrame::ProcessFontPreferences(wxCommandEvent& event)
/********************************************************************/
{
int id = event.GetId();
wxFont font;

	switch (id)
	{

		case ID_PREFERENCES_FONT:
		case ID_PREFERENCES_FONT_DIALOG:
		case ID_PREFERENCES_FONT_STATUS:
			WinEDA_BasicFrame::ProcessFontPreferences(id);
			break;


		case ID_PREFERENCES_FONT_INFOSCREEN:
		{
			font = wxGetFontFromUser(this, *g_MsgFont);
			if ( font.Ok() )
			{
				int pointsize = font.GetPointSize();
				*g_MsgFont = font;
				g_MsgFontPointSize = pointsize;
			}
			break;
		}
		default: DisplayError(this, wxT("WinEDA_DrawFrame::ProcessFontPreferences Internal Error") );
			break;
	}
}

/**************************************************************/
void WinEDA_DrawFrame::Affiche_Message(const wxString & message)
/**************************************************************/
/*
	Affiche un message en bas de l'ecran
*/
{
	SetStatusText(message);
}

/****************************************/
void WinEDA_DrawFrame::EraseMsgBox(void)
/****************************************/
{
	if ( MsgPanel ) MsgPanel->EraseMsgBox();
}


/*******************************************************/
void WinEDA_DrawFrame::OnActivate(wxActivateEvent& event)
/*******************************************************/
{
	m_FrameIsActive = event.GetActive();
	if ( DrawPanel )
		DrawPanel->m_CanStartBlock = -1;

	event.Skip();	// required under wxMAC
}


/****************************************************/
void WinEDA_DrawFrame::OnMenuOpen(wxMenuEvent& event)
/****************************************************/
{
	if ( DrawPanel ) DrawPanel->m_CanStartBlock = -1;
	event.Skip();
}


/*******************************************************/
void WinEDA_DrawFrame::ReCreateAuxiliaryToolbar(void)	// fonction virtuelle
/*******************************************************/
{
}

/********************************************/
void WinEDA_DrawFrame::ReCreateMenuBar(void)	// fonction virtuelle
/********************************************/
{
}

/****************************************************/
void WinEDA_DrawFrame::OnHotKey(wxDC * DC, int hotkey,
					EDA_BaseStruct * DrawStruct)	// fonction virtuelle
/****************************************************/
{
}



/**************************************************************/
void WinEDA_DrawFrame::ToolOnRightClick(wxCommandEvent & event)	// fonction virtuelle
/**************************************************************/
{
}

/********************************************************/
void WinEDA_DrawFrame::OnSelectGrid(wxCommandEvent& event)	// fonction virtuelle
/********************************************************/
{
	if ( m_SelGridBox == NULL ) return; //Ne devrait pas se produire!

int id = m_SelGridBox->GetChoice();
	if ( id < 0 ) return;

	m_CurrentScreen->m_Curseur = DrawPanel->GetScreenCenterRealPosition();
wxSize grid = m_CurrentScreen->GetGrid();
	m_CurrentScreen->SetGrid(g_GridList[id]);
wxSize newgrid = m_CurrentScreen->GetGrid();
	if ( newgrid.x != grid.x || newgrid.y != grid.y )
		Recadre_Trace(FALSE);
}


#ifndef EESCHEMA
/**************************************************************/
void WinEDA_DrawFrame::GeneralControle(wxDC *DC, wxPoint Mouse)
/**************************************************************/
/*	Fonction virtuelle
	traitement des touches de fonctions utilisees ds tous les menus
	Zoom
	Redessin d'ecran
	Cht Unites
	Cht couches
	Remise a 0 de l'origine des coordonnees relatives
*/
{
}
#endif


/********************************************************/
void WinEDA_DrawFrame::OnSelectZoom(wxCommandEvent& event)	// fonction virtuelle
/********************************************************/
/* Set the zoom when selected by the Zoom List Box
	Note:
		position 0 = Fit in Page
		position >= 1 = zoom (1 to zoom max)
		last position : special zoom
*/
{
	if ( m_SelZoomBox == NULL ) return; //Ne devrait pas se produire!

int id = m_SelZoomBox->GetChoice();

	if ( id < 0 ) return;	// No selection

	if ( id == 0 )			// Auto zoom (Fit in Page)
	{
		Zoom_Automatique(TRUE);
	}
	else if ( id == (int)(m_SelZoomBox->GetCount()-1) )	// Dummy position: unlisted zoom
		return ;
	else	// zooml 1 to zoom max
	{
		id --;
		int zoom = 1 << id;
		if ( zoom > m_ZoomMaxValue ) zoom = m_ZoomMaxValue;
		if ( m_CurrentScreen->GetZoom() == zoom) return;
		m_CurrentScreen->m_Curseur = DrawPanel->GetScreenCenterRealPosition();
		m_CurrentScreen->SetZoom(zoom);
		Recadre_Trace(FALSE);
	}
}

/********************************************************/
void WinEDA_DrawFrame::OnMouseEvent(wxMouseEvent& event)
/********************************************************/
{
	event.Skip();
}




/***********************************************************************/
// Virtuelle
void WinEDA_DrawFrame::OnLeftDClick(wxDC * DC, const wxPoint& MousePos)
/***********************************************************************/
{
}

/***************************************/
void WinEDA_DrawFrame::SetToolbars(void)
/***************************************/
{
	DisplayUnitsMsg();
}

/********************************************************/
void WinEDA_DrawFrame::DisplayToolMsg(const wxString msg)
/********************************************************/
{
	SetStatusText(msg, 5);
}

/*******************************************/
void WinEDA_DrawFrame::DisplayUnitsMsg(void)
/********************************************/
/* Display current unit Selection on Statusbar
*/
{
wxString msg;

	switch ( g_UnitMetric )
	{
		case INCHES:
			msg = _("Inch");
			break;
		case MILLIMETRE:
			msg += _("mm");
			break;
		default:
			msg += _("??");
			break;
	}

	SetStatusText(msg, 4);
}

/***************************************/
void WinEDA_DrawFrame::ReDrawPanel(void)
/***************************************/
{
	if ( DrawPanel == NULL ) return;
wxClientDC dc(DrawPanel);

	DrawPanel->PrepareGraphicContext(&dc);
	DrawPanel->ReDraw(&dc);
}

/**************************************************/
void WinEDA_DrawFrame::OnSize(wxSizeEvent & SizeEv)
/**************************************************/
/* recalcule les dimensions des toolbars et du panel d'affichage
*/
{
wxSize size;
wxSize opt_size;
wxSize Vtoolbar_size;
wxSize Auxtoolbar_size;

	GetClientSize(&size.x, &size.y);
	m_FrameSize = size;
	size.y -= m_MsgFrameHeight;

	if ( MsgPanel )	// Positionnement en bas d'ecran
	{
		MsgPanel->SetSize(0, size.y, size.x, m_MsgFrameHeight);
	}

	if( m_AuxiliaryToolBar )	// est sous le m_HToolBar
	{
		Auxtoolbar_size.x = size.x;		// = Largeur de la frame
		Auxtoolbar_size.y = m_AuxiliaryToolBar->GetSize().y;
		m_AuxiliaryToolBar->SetSize(Auxtoolbar_size);
		m_AuxiliaryToolBar->Move(0, 0);
		size.y -= Auxtoolbar_size.y;
	}

	if( m_VToolBar )	// Toolbar de droite: hauteur = hauteur utile de la frame-Auxtoolbar
	{
		Vtoolbar_size.x = m_VToolBar->GetSize().x;
		Vtoolbar_size.y = size.y;
		m_VToolBar->SetSize( Vtoolbar_size);
		m_VToolBar->Move(size.x - Vtoolbar_size.x, Auxtoolbar_size.y);
		m_VToolBar->Refresh();
	}

	if( m_AuxVToolBar )	// auxiliary vertical right toolbar, showing tools fo microwave applications
	{
		Vtoolbar_size.x += m_AuxVToolBar->GetSize().x;
		Vtoolbar_size.y = size.y;
		m_AuxVToolBar->SetSize( m_AuxVToolBar->GetSize().x, Vtoolbar_size.y);
		m_AuxVToolBar->Move(size.x - Vtoolbar_size.x, Auxtoolbar_size.y);
		m_AuxVToolBar->Refresh();
	}
	if( m_OptionsToolBar )
	{
		if ( m_OptionsToolBar->m_Horizontal)
		{
			opt_size.x = 0;
			opt_size.y = m_OptionsToolBar->GetSize().y;
			m_OptionsToolBar->SetSize(Auxtoolbar_size.x, 0, size.x, opt_size.y);
		}
		else
		{
			opt_size.x = m_OptionsToolBar->GetSize().x;
			opt_size.y = 0;
			m_OptionsToolBar->SetSize(0, Auxtoolbar_size.y, opt_size.x, size.y);
		}
	}

	if ( DrawPanel )
	{
		DrawPanel->SetSize( size.x - Vtoolbar_size.x - opt_size.x, size.y - opt_size.y - 1);
		DrawPanel->Move(opt_size.x, opt_size.y + Auxtoolbar_size.y + 1);
	}
	
	SizeEv.Skip();
}

/*************************************************************************/
void WinEDA_DrawFrame::SetToolID(int id, int new_cursor_id,
				const wxString & title)
/*************************************************************************/
/*
Active l'icone de l'outil selectionne dans le toolbar Vertical
( ou l'outil par defaut ID_NO_SELECT_BUTT si pas de nouvelle selection )
if ( id >= 0 )
	Met a jour toutes les variables associees:
		message, m_ID_current_state, curseur
si ( id < 0 )
	Met a jour seulement les variables message et  curseur
*/
{
	// Change Cursor
	if (DrawPanel )
	{
		DrawPanel->m_PanelDefaultCursor = new_cursor_id;
		DrawPanel->SetCursor( new_cursor_id );
	}
	SetCursor( wxCURSOR_ARROW );
	DisplayToolMsg(title);

	if ( id < 0 ) return;

	// Old Tool Inactif ou ID_NO_SELECT_BUTT actif si pas de nouveau Tool
	if ( m_ID_current_state )
	{
		if ( m_VToolBar ) m_VToolBar->ToggleTool(m_ID_current_state, FALSE);
		if ( m_AuxVToolBar ) m_AuxVToolBar->ToggleTool(m_ID_current_state, FALSE);
	}
	else
		{
		if ( id )
		{
			if ( m_VToolBar ) m_VToolBar->ToggleTool(ID_NO_SELECT_BUTT, FALSE);
			if ( m_AuxVToolBar ) m_AuxVToolBar->ToggleTool(m_ID_current_state, FALSE);
		}
		else if ( m_VToolBar ) m_VToolBar->ToggleTool(ID_NO_SELECT_BUTT, TRUE);
		}

	// New Tool Actif
	if ( id )
	{
		if ( m_VToolBar ) m_VToolBar->ToggleTool(id, TRUE);
		if ( m_AuxVToolBar ) m_AuxVToolBar->ToggleTool(id, TRUE);
	}
	else if ( m_VToolBar ) m_VToolBar->ToggleTool(ID_NO_SELECT_BUTT, TRUE);

	m_ID_current_state = id;
}


/********************************************/
void WinEDA_DrawFrame::OnZoom(int zoom_type)
/********************************************/

/* Fonction de traitement du zoom
	Modifie le facteur de zoom et reaffiche l'ecran
	Pour les commandes par menu Popup ou par le clavier, le curseur est
	replac<EFBFBD> au centre de l'ecran
*/
{
	if ( DrawPanel == NULL ) return;

bool move_mouse_cursor = FALSE;
int x,y;
wxPoint old_pos;

	DrawPanel->GetViewStart( &x, &y );
	old_pos = m_CurrentScreen->m_Curseur;

	switch (zoom_type)
		{
		case ID_POPUP_ZOOM_PLUS:
		case ID_ZOOM_PLUS_KEY:
			move_mouse_cursor = TRUE;
		case ID_ZOOM_PLUS_BUTT:
			if ( zoom_type == ID_ZOOM_PLUS_BUTT)
				m_CurrentScreen->m_Curseur = DrawPanel->GetScreenCenterRealPosition();
			m_CurrentScreen->SetPreviousZoom();
			Recadre_Trace(move_mouse_cursor);
			break;

		case ID_POPUP_ZOOM_MOINS:
		case ID_ZOOM_MOINS_KEY:
			move_mouse_cursor = TRUE;
		case ID_ZOOM_MOINS_BUTT:
			if ( zoom_type == ID_ZOOM_MOINS_BUTT)
				m_CurrentScreen->m_Curseur = DrawPanel->GetScreenCenterRealPosition();
			m_CurrentScreen->SetNextZoom();
			Recadre_Trace(move_mouse_cursor);
			break;

		case ID_POPUP_ZOOM_REDRAW:
		case ID_ZOOM_REDRAW_KEY:
		case ID_ZOOM_REDRAW_BUTT:
			ReDrawPanel();
			break;

		case ID_POPUP_ZOOM_CENTER:
		case ID_ZOOM_CENTER_KEY:
			Recadre_Trace(TRUE);
			break;

		case ID_ZOOM_PAGE_BUTT:
		case ID_ZOOM_AUTO:
		case ID_POPUP_ZOOM_AUTO:
			Zoom_Automatique(FALSE);
			break;

		case ID_ZOOM_PANNING_UP:
			OnPanning(ID_ZOOM_PANNING_UP);
			break;

		case ID_ZOOM_PANNING_DOWN:
			OnPanning(ID_ZOOM_PANNING_DOWN);
			break;

		case ID_ZOOM_PANNING_LEFT:
			OnPanning(ID_ZOOM_PANNING_LEFT);
			DrawPanel->CursorOn(NULL);
			break;

		case ID_ZOOM_PANNING_RIGHT:
			OnPanning(ID_ZOOM_PANNING_RIGHT);
			break;


		default: wxMessageBox( wxT("WinEDA_DrawFrame::OnZoom switch Error") );
			break;
		}
	Affiche_Status_Box();
}

/**********************************************/
void WinEDA_DrawFrame::OnPanning(int direction)
/**********************************************/

/* Fonction de traitement du zoom
	Modifie le facteur de zoom et reaffiche l'ecran
	Pour les commandes par menu Popup ou par le clavier, le curseur est
	replac<EFBFBD> au centre de l'ecran
*/
{
	if ( DrawPanel == NULL ) return;

int delta;
wxClientDC dc(DrawPanel);
int x,y;


	DrawPanel->PrepareGraphicContext(&dc);
	DrawPanel->GetViewStart( &x, &y );	// x and y are in scroll unit, not in pixels
	delta = DrawPanel->m_ScrollButt_unit;
	switch (direction)
	{
		case ID_ZOOM_PANNING_UP:
			y -= delta;
		break;

		case ID_ZOOM_PANNING_DOWN:
			y += delta;
			break;

		case ID_ZOOM_PANNING_LEFT:
			x -= delta;
			break;

		case ID_ZOOM_PANNING_RIGHT:
			x += delta;
			break;

		default: wxMessageBox( wxT("WinEDA_DrawFrame::OnPanning Error") );
			break;
	}

	DrawPanel->Scroll(x, y);

	/* Place le curseur souris sur le curseur SCHEMA*/
	DrawPanel->MouseToCursorSchema();
}


	/*****************************/
	/* default virtual fonctions */
	/*****************************/

void WinEDA_DrawFrame::OnGrid(int grid_type)
{
}

int WinEDA_DrawFrame::ReturnBlockCommand(int key)
{
	return 0;
}

void WinEDA_DrawFrame::InitBlockPasteInfos()
{
	GetScreen()->BlockLocate.m_BlockDrawStruct = NULL;
	DrawPanel->ManageCurseur = NULL;
}

void WinEDA_DrawFrame::HandleBlockPlace(wxDC * DC)
{
}

int WinEDA_DrawFrame::HandleBlockEnd(wxDC * DC)
{
	return 0;
}




/*********************************************/
void WinEDA_DrawFrame::AdjustScrollBars(void)
/*********************************************/
{
wxSize draw_size, panel_size;
wxSize scrollbar_number;
wxPoint scrollbar_pos;
int zoom = m_CurrentScreen->GetZoom();
int xUnit, yUnit;

	if ( m_CurrentScreen == NULL) return;
	if ( DrawPanel == NULL ) return;

	draw_size = m_CurrentScreen->ReturnPageSize();

	// La zone d'affichage est reglee a une taille double de la feuille de travail:
	draw_size.x *= 2; draw_size.y *= 2;

	// On utilise le centre de l'ecran comme position de reference, donc
	// la surface de trace doit etre augmentee
	panel_size = DrawPanel->GetClientSize();
	panel_size.x *= zoom; panel_size.y *= zoom;
	draw_size.x += panel_size.x/2;
	draw_size.y += panel_size.y/2;


	if ( m_CurrentScreen->m_Center )
	{
		m_CurrentScreen->m_DrawOrg.x = - draw_size.x/2;
		m_CurrentScreen->m_DrawOrg.y = - draw_size.y/2;
	}
	else
	{
		m_CurrentScreen->m_DrawOrg.x = - panel_size.x/2;
		m_CurrentScreen->m_DrawOrg.y = - panel_size.y/2;
	}

	// DrawOrg est rendu multiple du zoom min :
	m_CurrentScreen->m_DrawOrg.x -= m_CurrentScreen->m_DrawOrg.x % 256;
	m_CurrentScreen->m_DrawOrg.y -= m_CurrentScreen->m_DrawOrg.y % 256;

	// Calcul du nombre de scrolls  (en unites de scrool )
	scrollbar_number.x = draw_size.x / (DrawPanel->m_Scroll_unit*zoom);
	scrollbar_number.y = draw_size.y / (DrawPanel->m_Scroll_unit*zoom);

	xUnit = yUnit = DrawPanel->m_Scroll_unit;

	if (xUnit <= 1 ) xUnit = 1;
	if (yUnit <= 1 ) yUnit = 1;
	xUnit *= zoom; yUnit *= zoom;

	// Calcul de la position, curseur place au centre d'ecran
	scrollbar_pos = m_CurrentScreen->m_Curseur;

	scrollbar_pos.x -= m_CurrentScreen->m_DrawOrg.x;
	scrollbar_pos.y -= m_CurrentScreen->m_DrawOrg.y;

	scrollbar_pos.x -= panel_size.x /2;
	scrollbar_pos.y -= panel_size.y /2;

	if ( scrollbar_pos.x < 0 ) scrollbar_pos.x = 0;
	if ( scrollbar_pos.y < 0 ) scrollbar_pos.y = 0;

	scrollbar_pos.x /= xUnit;
	scrollbar_pos.y /= yUnit;
	m_CurrentScreen->m_ScrollbarPos = scrollbar_pos;
	m_CurrentScreen->m_ScrollbarNumber = scrollbar_number;

	DrawPanel->SetScrollbars( DrawPanel->m_Scroll_unit,
							DrawPanel->m_Scroll_unit,
							m_CurrentScreen->m_ScrollbarNumber.x,
							m_CurrentScreen->m_ScrollbarNumber.y,
							m_CurrentScreen->m_ScrollbarPos.x,
							m_CurrentScreen->m_ScrollbarPos.y, TRUE);

}



/****************************************************/
void WinEDA_DrawFrame::SetDrawBgColor(int color_num)
/****************************************************/
/* met a jour la couleur de fond pour les trac<61>s
	seules les couleurs BLACK ou WHITE sont autoris<EFBFBD>es
	le parametre XorMode est mis a jour selon la couleur du fond
*/
{
	if ( (color_num != WHITE) && (color_num != BLACK) ) color_num = BLACK;
	g_DrawBgColor = color_num;
	if(color_num == WHITE)
	{
		g_XorMode = GR_NXOR;
		g_GhostColor = BLACK;
	}
	else
	{
		g_XorMode = GR_XOR;
		g_GhostColor = WHITE;
	}

	if ( DrawPanel )
		DrawPanel-> SetBackgroundColour(wxColour(ColorRefs[g_DrawBgColor].m_Red,
						ColorRefs[g_DrawBgColor].m_Green,
						ColorRefs[g_DrawBgColor].m_Blue ));

}


/********************************************************/
void WinEDA_DrawFrame::SetLanguage(wxCommandEvent& event)
/********************************************************/
{
int id = event.GetId();

	m_Parent->SetLanguageIdentifier(id );
	m_Parent->SetLanguage();
}


/***********************************************/
void WinEDA_DrawFrame::Affiche_Status_Box(void)
/***********************************************/
/* Routine d'affichage du zoom et des coord curseur.
*/
{
wxString Line;
int dx, dy;

	if (GetScreen() == NULL ) return;

	/* affichage Zoom et coordonnees absolues */
	Line.Printf(wxT("Z %d"), GetScreen()->GetZoom());
	SetStatusText(Line, 1);

	Line.Printf( g_UnitMetric ? wxT("X %.3f  Y %.3f") : wxT("X %.4f  Y %.4f"),
						To_User_Unit(g_UnitMetric, GetScreen()->m_Curseur.x,
						m_InternalUnits),
						To_User_Unit(g_UnitMetric, GetScreen()->m_Curseur.y,
						m_InternalUnits));
	SetStatusText(Line, 2);

	/* affichage des coordonnees relatives  */
	dx = GetScreen()->m_Curseur.x - GetScreen()->m_O_Curseur.x;
	dy = GetScreen()->m_Curseur.y - GetScreen()->m_O_Curseur.y;

	Line.Printf( g_UnitMetric ? wxT("x %.3f  y %.3f") : wxT("x %.4f  y %.4f"),
		To_User_Unit(g_UnitMetric, dx, m_InternalUnits),
		To_User_Unit(g_UnitMetric, dy, m_InternalUnits) );

	SetStatusText(Line, 3);

#ifdef PCBNEW
	if ( DisplayOpt.DisplayPolarCood )	/* Display coordonnee polaire */
		{
		double theta, ro;
		if ( (dx == 0) && (dy == 0) ) theta = 0.0;
		else theta = atan2( (double) - dy , (double) dx );
		theta = theta *180 / M_PI;

		ro = sqrt( ((double) dx * dx) + ((double)dy * dy) );
		Line.Printf( g_UnitMetric ? wxT("Ro %.3f Th %.1f") : wxT("Ro %.4f Th %.1f"),
			To_User_Unit(g_UnitMetric, (int) round(ro), m_InternalUnits),
				theta) ;
		SetStatusText(Line, 0);
		}
#endif
}