934 lines
24 KiB
C++
934 lines
24 KiB
C++
/******************************************************************/
|
||
/* drawpanel.cpp - fonctions des classes du type WinEDA_DrawPanel */
|
||
/******************************************************************/
|
||
|
||
#ifdef __GNUG__
|
||
#pragma implementation
|
||
#endif
|
||
|
||
#include "fctsys.h"
|
||
#include "common.h"
|
||
|
||
#include "macros.h"
|
||
#include "id.h"
|
||
|
||
/* defines locaux */
|
||
#define CURSOR_SIZE 12 /* taille de la croix du curseur PCB */
|
||
|
||
/* Variables locales */
|
||
|
||
/* table des evenements captes par un WinEDA_DrawPanel */
|
||
BEGIN_EVENT_TABLE(WinEDA_DrawPanel, EDA_DRAW_PANEL)
|
||
EVT_LEAVE_WINDOW(WinEDA_DrawPanel::OnMouseLeaving)
|
||
EVT_MOUSE_EVENTS(WinEDA_DrawPanel::OnMouseEvent)
|
||
EVT_CHAR(WinEDA_DrawPanel::OnKeyEvent)
|
||
EVT_CHAR_HOOK(WinEDA_DrawPanel::OnKeyEvent)
|
||
EVT_PAINT(WinEDA_DrawPanel::OnPaint)
|
||
EVT_SIZE(WinEDA_DrawPanel::OnSize)
|
||
EVT_ERASE_BACKGROUND(WinEDA_DrawPanel::OnEraseBackground)
|
||
EVT_SCROLLWIN(WinEDA_DrawPanel::OnScroll)
|
||
EVT_ACTIVATE(WinEDA_DrawPanel::OnActivate)
|
||
|
||
EVT_MENU_RANGE( ID_POPUP_ZOOM_START_RANGE, ID_POPUP_ZOOM_END_RANGE,
|
||
WinEDA_DrawPanel::Process_Popup_Zoom)
|
||
|
||
END_EVENT_TABLE()
|
||
|
||
|
||
|
||
|
||
/***********************************************************/
|
||
/* Fonctions de base de WinEDA_DrawPanel: l'ecran de trace */
|
||
/***********************************************************/
|
||
|
||
WinEDA_DrawPanel::WinEDA_DrawPanel(WinEDA_DrawFrame *parent, int id,
|
||
const wxPoint& pos, const wxSize& size):
|
||
EDA_DRAW_PANEL(parent, id, pos, size,
|
||
wxBORDER|wxNO_FULL_REPAINT_ON_RESIZE)
|
||
{
|
||
m_Parent = parent;
|
||
m_Ident = m_Parent->m_Ident;
|
||
m_Scroll_unit = 1;
|
||
m_ScrollButt_unit = 40;
|
||
SetBackgroundColour(wxColour(ColorRefs[g_DrawBgColor].m_Red,
|
||
ColorRefs[g_DrawBgColor].m_Green,
|
||
ColorRefs[g_DrawBgColor].m_Blue ) );
|
||
EnableScrolling(TRUE,TRUE);
|
||
m_ClipBox.SetSize(size);
|
||
m_ClipBox.SetX(0);
|
||
m_ClipBox.SetY(0);
|
||
m_CanStartBlock = -1; // Command block can start if >= 0
|
||
m_AbortEnable = m_AbortRequest = FALSE;
|
||
m_AutoPAN_Enable = TRUE;
|
||
m_IgnoreMouseEvents = FALSE;
|
||
|
||
ManageCurseur = NULL;
|
||
ForceCloseManageCurseur = NULL;
|
||
|
||
if ( m_Parent->m_Parent->m_EDA_Config )
|
||
m_AutoPAN_Enable = m_Parent->m_Parent->m_EDA_Config->Read(wxT("AutoPAN"), TRUE);
|
||
m_AutoPAN_Request = FALSE;
|
||
m_Block_Enable = FALSE;
|
||
m_PanelDefaultCursor = m_PanelCursor = wxCURSOR_ARROW;
|
||
m_CursorLevel = 0;
|
||
}
|
||
|
||
/*********************************************************************************/
|
||
void WinEDA_DrawPanel::Trace_Curseur(wxDC * DC, int color)
|
||
/*********************************************************************************/
|
||
/*
|
||
Trace Le curseur sur la zone PCB , se deplacant sur la grille
|
||
*/
|
||
{
|
||
if (m_CursorLevel != 0) {
|
||
return;
|
||
}
|
||
|
||
wxPoint Cursor = GetScreen()->m_Curseur;
|
||
|
||
if ( DC == NULL ) return;
|
||
|
||
GRSetDrawMode(DC, GR_XOR);
|
||
if( g_CursorShape == 1 ) /* Trace d'un reticule */
|
||
{
|
||
int dx = m_ClipBox.GetWidth() * GetZoom();
|
||
int dy = m_ClipBox.GetHeight() * GetZoom();
|
||
GRLine(&m_ClipBox, DC, Cursor.x - dx, Cursor.y,
|
||
Cursor.x + dx, Cursor.y, 0, color); // axe Y
|
||
GRLine(&m_ClipBox, DC, Cursor.x, Cursor.y - dx,
|
||
Cursor.x, Cursor.y + dy, 0, color); // axe X
|
||
}
|
||
|
||
else
|
||
{
|
||
int len = CURSOR_SIZE * GetZoom();
|
||
GRLine(&m_ClipBox, DC, Cursor.x - len, Cursor.y,
|
||
Cursor.x + len, Cursor.y, 0, color);
|
||
GRLine(&m_ClipBox, DC, Cursor.x, Cursor.y - len,
|
||
Cursor.x, Cursor.y + len, 0, color);
|
||
}
|
||
}
|
||
|
||
/*******************************************************************/
|
||
void WinEDA_DrawPanel::CursorOff(wxDC * DC)
|
||
/*******************************************************************/
|
||
/*
|
||
Remove the grid cursor from the display in preparation for other drawing operations
|
||
*/
|
||
{
|
||
Trace_Curseur(DC);
|
||
--m_CursorLevel;
|
||
}
|
||
|
||
/*******************************************************************/
|
||
void WinEDA_DrawPanel::CursorOn(wxDC * DC)
|
||
/*******************************************************************/
|
||
/*
|
||
Display the grid cursor
|
||
*/
|
||
{
|
||
++m_CursorLevel;
|
||
Trace_Curseur(DC);
|
||
|
||
if (m_CursorLevel > 0) // Shouldn't happen, but just in case ..
|
||
m_CursorLevel = 0;
|
||
}
|
||
|
||
|
||
/***********************************/
|
||
int WinEDA_DrawPanel::GetZoom(void)
|
||
/***********************************/
|
||
{
|
||
return GetScreen()->GetZoom();
|
||
}
|
||
|
||
/***************************************/
|
||
void WinEDA_DrawPanel::SetZoom(int zoom)
|
||
/***************************************/
|
||
{
|
||
GetScreen()->SetZoom(zoom);
|
||
}
|
||
|
||
/************************************/
|
||
wxSize WinEDA_DrawPanel::GetGrid(void)
|
||
/************************************/
|
||
{
|
||
return GetScreen()->GetGrid();
|
||
}
|
||
|
||
|
||
/******************************************************/
|
||
void WinEDA_DrawPanel::PrepareGraphicContext(wxDC * DC)
|
||
/******************************************************/
|
||
{
|
||
GRResetPenAndBrush(DC);
|
||
DC->SetBackgroundMode(wxTRANSPARENT);
|
||
#ifdef WX_ZOOM
|
||
int zoom = GetZoom();
|
||
double f_scale = 1.0/(double)zoom;
|
||
|
||
DC->SetUserScale(f_scale, f_scale);
|
||
PrepareDC(*DC);
|
||
#endif
|
||
SetBoundaryBox();
|
||
}
|
||
|
||
|
||
/*********************************************************************/
|
||
wxPoint WinEDA_DrawPanel::CalcAbsolutePosition(const wxPoint & rel_pos)
|
||
/*********************************************************************/
|
||
/* retourne la position absolue en pixels de la position rel_pos,
|
||
donn<EFBFBD>e en position relative scroll<6C>e (en pixel)
|
||
*/
|
||
{
|
||
wxPoint pos;
|
||
|
||
#ifdef WX_ZOOM
|
||
CalcUnscrolledPosition( rel_pos.x, rel_pos.y, &pos.x, &pos.y );
|
||
#else
|
||
int ii, jj;
|
||
GetViewStart(&pos.x, &pos.y);
|
||
GetScrollPixelsPerUnit(&ii, &jj);
|
||
pos.x *= ii; pos.y *= jj;
|
||
pos.x += rel_pos.x;
|
||
pos.y += rel_pos.y;
|
||
#endif
|
||
return pos;
|
||
}
|
||
|
||
|
||
/**********************************************************************/
|
||
wxPoint WinEDA_DrawPanel::CursorRealPosition(const wxPoint & ScreenPos)
|
||
/**********************************************************************/
|
||
/* Retourne la position en unites utilisateur du pointeur souris
|
||
ScreenPos = position pointeur en coord absolue ecran
|
||
*/
|
||
{
|
||
wxPoint curpos;
|
||
|
||
curpos = GetScreen()->CursorRealPosition(ScreenPos);
|
||
|
||
return curpos;
|
||
}
|
||
|
||
/********************************************************/
|
||
bool WinEDA_DrawPanel::IsPointOnDisplay(wxPoint ref_pos)
|
||
/********************************************************/
|
||
/* retourne TRUE si le point de coord physique ref_pos
|
||
est visible sur l'ecran, c'est a dire:
|
||
si ref_pos est sur la partie du schema ou pcb affichee a l'ecran
|
||
*/
|
||
{
|
||
wxPoint pos;
|
||
EDA_Rect display_rect;
|
||
|
||
SetBoundaryBox();
|
||
display_rect = m_ClipBox;
|
||
|
||
// Reduction legere des dimension de l'ecran utile pour eviter cadrage
|
||
// en limite d'ecran
|
||
#define PIXEL_MARGIN 8
|
||
display_rect.Inflate(-PIXEL_MARGIN,-PIXEL_MARGIN);
|
||
|
||
// Conversion en coord physiques
|
||
pos = CalcAbsolutePosition( display_rect.GetPosition() );
|
||
pos.x *= GetZoom();
|
||
pos.y *= GetZoom();
|
||
pos.x += GetScreen()->m_DrawOrg.x;
|
||
pos.y += GetScreen()->m_DrawOrg.y;
|
||
display_rect.SetX(pos.x); display_rect.SetY(pos.y);
|
||
display_rect.SetWidth( display_rect.GetWidth() * GetZoom() );
|
||
display_rect.SetHeight( display_rect.GetHeight() * GetZoom() );
|
||
|
||
return display_rect.Inside(ref_pos);
|
||
}
|
||
|
||
|
||
/********************************************************/
|
||
wxPoint WinEDA_DrawPanel::CursorScreenPosition(void)
|
||
/********************************************************/
|
||
/* retourne la position sur l'ecran,en pixels, du curseur
|
||
Orgine = coord absolue 0,0;
|
||
*/
|
||
{
|
||
wxPoint curpos = GetScreen()->m_Curseur;
|
||
|
||
curpos.x -= GetScreen()->m_DrawOrg.x;
|
||
curpos.y -= GetScreen()->m_DrawOrg.y;
|
||
|
||
curpos.x /= GetZoom();
|
||
curpos.y /= GetZoom();
|
||
|
||
return curpos;
|
||
}
|
||
|
||
/*********************************************************/
|
||
wxPoint WinEDA_DrawPanel::GetScreenCenterRealPosition(void)
|
||
/*********************************************************/
|
||
{
|
||
wxSize size;
|
||
wxPoint realpos;
|
||
|
||
size = GetClientSize();
|
||
size.x /= 2; size.y /= 2;
|
||
|
||
realpos = CalcAbsolutePosition( wxPoint(size.x, size.y) );
|
||
realpos.x *= GetZoom();
|
||
realpos.y *= GetZoom();
|
||
realpos.x += GetScreen()->m_DrawOrg.x;
|
||
realpos.y += GetScreen()->m_DrawOrg.y;
|
||
|
||
return realpos;
|
||
}
|
||
|
||
|
||
/**********************************************/
|
||
void WinEDA_DrawPanel::MouseToCursorSchema(void)
|
||
/**********************************************/
|
||
/* place le curseur souris sur la position du curseur schema
|
||
*/
|
||
{
|
||
wxPoint Mouse = CursorScreenPosition();
|
||
MouseTo(Mouse);
|
||
}
|
||
|
||
/****************************************************/
|
||
void WinEDA_DrawPanel::MouseTo(const wxPoint & Mouse)
|
||
/****************************************************/
|
||
/* place le curseur souris sur la position Mouse
|
||
*/
|
||
{
|
||
wxPoint mouse;
|
||
#ifdef WX_ZOOM
|
||
CalcScrolledPosition(Mouse.x, Mouse.y, &mouse.x, &mouse.y);
|
||
#else
|
||
mouse = Mouse;
|
||
mouse.x -= GetScreen()->m_StartVisu.x;
|
||
mouse.y -= GetScreen()->m_StartVisu.y;
|
||
#endif
|
||
GRMouseWarp(this, mouse);
|
||
}
|
||
|
||
/********************************************************/
|
||
void WinEDA_DrawPanel::OnActivate(wxActivateEvent& event)
|
||
/********************************************************/
|
||
{
|
||
m_CanStartBlock = -1; // Commande block can't start
|
||
event.Skip();
|
||
}
|
||
|
||
|
||
/***********************************************************/
|
||
void WinEDA_DrawPanel::OnEraseBackground(wxEraseEvent& event)
|
||
/***********************************************************/
|
||
{
|
||
event.Skip();
|
||
}
|
||
|
||
/*********************************************************/
|
||
void WinEDA_DrawPanel::OnScroll( wxScrollWinEvent &event )
|
||
/*********************************************************/
|
||
{
|
||
int id = event.GetEventType();
|
||
int dir, value = 0;
|
||
int x,y;
|
||
|
||
GetViewStart( &x, &y );
|
||
dir = event.GetOrientation(); // wxHORIZONTAL ou wxVERTICAL
|
||
|
||
if ( id == wxEVT_SCROLLWIN_LINEUP) value = - m_ScrollButt_unit;
|
||
|
||
else if ( id == wxEVT_SCROLLWIN_LINEDOWN) value = m_ScrollButt_unit;
|
||
|
||
else if ( id == wxEVT_SCROLLWIN_THUMBTRACK )
|
||
{
|
||
value = event.GetPosition();
|
||
if ( dir == wxHORIZONTAL ) Scroll( value, -1 );
|
||
else Scroll( -1, value );
|
||
return;
|
||
}
|
||
|
||
else
|
||
{
|
||
event.Skip();
|
||
return;
|
||
}
|
||
|
||
if ( dir == wxHORIZONTAL )
|
||
{
|
||
Scroll( x + value, -1 );
|
||
}
|
||
else
|
||
{
|
||
Scroll( -1, y + value );
|
||
}
|
||
event.Skip();
|
||
}
|
||
|
||
|
||
/*************************************************/
|
||
void WinEDA_DrawPanel::OnSize(wxSizeEvent & event)
|
||
/*************************************************/
|
||
{
|
||
SetBoundaryBox();
|
||
event.Skip();
|
||
}
|
||
|
||
/******************************************/
|
||
void WinEDA_DrawPanel::SetBoundaryBox(void)
|
||
/******************************************/
|
||
{
|
||
BASE_SCREEN * Screen = GetScreen();;
|
||
wxPoint org;
|
||
int ii, jj;
|
||
|
||
Screen->m_SizeVisu = GetClientSize();
|
||
GetViewStart(&org.x, &org.y);
|
||
|
||
GetScrollPixelsPerUnit(&ii, &jj);
|
||
org.x *= ii; org.y *= jj;
|
||
Screen->m_StartVisu = org;
|
||
|
||
m_ClipBox.SetOrigin(org);
|
||
m_ClipBox.SetSize(GetClientSize());
|
||
|
||
#ifdef WX_ZOOM
|
||
m_ClipBox.m_Pos.x *= GetZoom();
|
||
m_ClipBox.m_Pos.y *= GetZoom();
|
||
m_ClipBox.m_Size.x *= GetZoom();
|
||
m_ClipBox.m_Size.y *= GetZoom();
|
||
#else
|
||
m_ClipBox.m_Pos.x -= GetScreen()->m_StartVisu.x;
|
||
m_ClipBox.m_Pos.y -= GetScreen()->m_StartVisu.y;
|
||
#endif
|
||
|
||
m_ScrollButt_unit = MIN( Screen->m_SizeVisu.x, Screen->m_SizeVisu.y ) / 4;
|
||
if ( m_ScrollButt_unit < 2 ) m_ScrollButt_unit = 2;
|
||
|
||
Screen->m_ScrollbarPos.x = GetScrollPos(wxHORIZONTAL);
|
||
Screen->m_ScrollbarPos.y = GetScrollPos(wxVERTICAL);
|
||
}
|
||
|
||
|
||
/*********************************************/
|
||
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 WinEDA_DrawPanel::OnPaint(wxPaintEvent & event)
|
||
/***************************************************/
|
||
{
|
||
wxPaintDC paintDC(this);
|
||
EDA_Rect tmp;
|
||
wxRect PaintClipBox;
|
||
wxPoint org;
|
||
|
||
PrepareGraphicContext(&paintDC);
|
||
tmp = m_ClipBox;
|
||
|
||
org = m_ClipBox.GetOrigin();
|
||
|
||
wxRegionIterator upd(GetUpdateRegion()); // get the update rect list
|
||
|
||
while ( upd )
|
||
{
|
||
PaintClipBox = upd.GetRect();
|
||
upd++;
|
||
|
||
PaintClipBox.x += org.x;
|
||
PaintClipBox.y += org.y;
|
||
|
||
#ifdef WX_ZOOM
|
||
m_ClipBox.m_Pos.x = PaintClipBox.x * GetZoom();
|
||
m_ClipBox.m_Pos.y = PaintClipBox.y * GetZoom();
|
||
m_ClipBox.m_Size.x = PaintClipBox.m_Size.x * GetZoom();
|
||
m_ClipBox.m_Size.y = PaintClipBox.m_Size.y * GetZoom();
|
||
PaintClipBox = m_ClipBox;
|
||
#else
|
||
m_ClipBox.SetX(PaintClipBox.GetX());
|
||
m_ClipBox.SetY(PaintClipBox.GetY());
|
||
m_ClipBox.SetWidth(PaintClipBox.GetWidth());
|
||
m_ClipBox.SetHeight(PaintClipBox.GetHeight());
|
||
#endif
|
||
|
||
wxDCClipper * dcclip = new wxDCClipper(paintDC, PaintClipBox);
|
||
ReDraw(&paintDC, TRUE);
|
||
delete dcclip;
|
||
}
|
||
|
||
m_ClipBox = tmp;
|
||
event.Skip();
|
||
}
|
||
|
||
/****************************************************/
|
||
void WinEDA_DrawPanel::ReDraw(wxDC * DC, bool erasebg)
|
||
/****************************************************/
|
||
{
|
||
BASE_SCREEN * Screen = GetScreen();
|
||
|
||
if ( Screen == NULL ) return;
|
||
|
||
if ( (g_DrawBgColor != WHITE) && (g_DrawBgColor != BLACK) ) g_DrawBgColor = BLACK;
|
||
if(g_DrawBgColor == WHITE)
|
||
{
|
||
g_XorMode = GR_NXOR;
|
||
g_GhostColor = BLACK;
|
||
}
|
||
else
|
||
{
|
||
g_XorMode = GR_XOR;
|
||
g_GhostColor = WHITE;
|
||
}
|
||
|
||
#ifdef WX_ZOOM
|
||
int zoom = GetZoom();
|
||
double f_scale = 1.0/(double)zoom;
|
||
DC->SetUserScale(f_scale, f_scale);
|
||
#endif
|
||
|
||
|
||
if(erasebg) PrepareGraphicContext(DC);
|
||
DC->SetFont(* g_StdFont);
|
||
|
||
SetBackgroundColour(wxColour(ColorRefs[g_DrawBgColor].m_Red,
|
||
ColorRefs[g_DrawBgColor].m_Green,
|
||
ColorRefs[g_DrawBgColor].m_Blue ));
|
||
|
||
GRResetPenAndBrush(DC);
|
||
|
||
DC->SetBackground(*wxBLACK_BRUSH );
|
||
DC->SetBackgroundMode(wxTRANSPARENT);
|
||
m_Parent->RedrawActiveWindow(DC, erasebg);
|
||
}
|
||
|
||
/***********************************************/
|
||
void WinEDA_DrawPanel::DrawBackGround(wxDC * DC)
|
||
/***********************************************/
|
||
/* Trace les axes X et Y et la grille
|
||
La grille n'est affichee que si elle peut etre facilement visible
|
||
La grille passe toujours par le centre de l'ecran
|
||
*/
|
||
{
|
||
int Color = BLUE;
|
||
BASE_SCREEN * screen = GetScreen();
|
||
int ii,jj ,xg , yg , color;
|
||
wxSize pas_grille_affichee;
|
||
bool drawgrid = FALSE;
|
||
int zoom = GetZoom();
|
||
wxSize size;
|
||
wxPoint org;
|
||
double pasx, pasy;
|
||
|
||
color = g_GridColor;
|
||
GRSetDrawMode(DC, GR_COPY);
|
||
|
||
/* le pas d'affichage doit etre assez grand pour avoir une grille visible */
|
||
drawgrid = m_Parent->m_Draw_Grid;
|
||
pas_grille_affichee = screen->GetGrid();
|
||
|
||
ii = pas_grille_affichee.x / zoom;
|
||
if (ii < 5 ) { pas_grille_affichee.x *= 2 ; ii *= 2; }
|
||
if( ii < 5 ) drawgrid = FALSE; // grille trop petite
|
||
ii = pas_grille_affichee.y / zoom;
|
||
if (ii < 5 ) { pas_grille_affichee.y *= 2 ; ii *= 2; }
|
||
if( ii < 5 ) drawgrid = FALSE; // grille trop petite
|
||
|
||
GetViewStart(&org.x, &org.y);
|
||
GetScrollPixelsPerUnit(&ii, &jj);
|
||
org.x *= ii; org.y *= jj;
|
||
screen->m_StartVisu = org;
|
||
|
||
org.x *= zoom; org.y *= zoom;
|
||
org.x += screen->m_DrawOrg.x; org.y += screen->m_DrawOrg.y;
|
||
|
||
size = GetClientSize();
|
||
size.x *= zoom; size.y *= zoom;
|
||
pasx = screen->m_UserGrid.x * m_Parent->m_InternalUnits;
|
||
pasy = screen->m_UserGrid.y * m_Parent->m_InternalUnits;
|
||
if ( screen->m_UserGridUnit != INCHES )
|
||
{
|
||
pasx /= 25.4; pasy /= 25.4;
|
||
}
|
||
|
||
if( drawgrid)
|
||
{
|
||
m_Parent->PutOnGrid(&org) ;
|
||
|
||
GRSetColorPen(DC, color );
|
||
for ( ii = 0 ; ; ii++ )
|
||
{
|
||
xg = screen->m_UserGridIsON ? (int)( (ii * pasx) + 0.5)
|
||
:ii * pas_grille_affichee.x;
|
||
int xpos = org.x + xg;
|
||
for ( jj = 0 ; ; jj++ )
|
||
{
|
||
yg = screen->m_UserGridIsON ? (int)( (jj * pasy) + 0.5)
|
||
: jj * pas_grille_affichee.y;
|
||
GRPutPixel(&m_ClipBox, DC, xpos, org.y + yg, color);
|
||
if ( yg > size.y ) break;
|
||
}
|
||
if ( xg > size.x ) break;
|
||
}
|
||
}
|
||
|
||
/* trace des axes principaux */
|
||
if ( m_Parent->m_Draw_Axis )
|
||
{
|
||
/* Trace de l'axe vertical */
|
||
GRDashedLine(&m_ClipBox, DC, 0, -screen->ReturnPageSize().y,
|
||
0, screen->ReturnPageSize().y, 0, Color );
|
||
|
||
/* Trace de l'axe horizontal */
|
||
GRDashedLine(&m_ClipBox, DC, -screen->ReturnPageSize().x, 0,
|
||
screen->ReturnPageSize().x, 0, 0, Color );
|
||
}
|
||
|
||
/* trace des axes auxiliaires */
|
||
if ( m_Parent->m_Draw_Auxiliary_Axis)
|
||
{
|
||
m_Draw_Auxiliary_Axis(DC, FALSE);
|
||
}
|
||
}
|
||
|
||
/********************************************************************/
|
||
void WinEDA_DrawPanel::m_Draw_Auxiliary_Axis(wxDC * DC, int drawmode)
|
||
/********************************************************************/
|
||
{
|
||
if ( m_Parent->m_Auxiliary_Axis_Position.x == 0 &&
|
||
m_Parent->m_Auxiliary_Axis_Position.y == 0 )
|
||
return;
|
||
|
||
int Color = DARKRED;
|
||
BASE_SCREEN * screen = GetScreen();
|
||
|
||
GRSetDrawMode(DC, drawmode);
|
||
|
||
/* Trace de l'axe vertical */
|
||
GRDashedLine(&m_ClipBox, DC,
|
||
m_Parent->m_Auxiliary_Axis_Position.x, -screen->ReturnPageSize().y,
|
||
m_Parent->m_Auxiliary_Axis_Position.x, screen->ReturnPageSize().y,
|
||
0, Color );
|
||
|
||
/* Trace de l'axe horizontal */
|
||
GRDashedLine(&m_ClipBox, DC,
|
||
-screen->ReturnPageSize().x, m_Parent->m_Auxiliary_Axis_Position.y,
|
||
screen->ReturnPageSize().x, m_Parent->m_Auxiliary_Axis_Position.y,
|
||
0, Color );
|
||
}
|
||
|
||
/*******************************************************/
|
||
void WinEDA_DrawPanel::OnRightClick(wxMouseEvent& event)
|
||
/*******************************************************/
|
||
/* Construit et affiche un menu Popup lorsque on actionne le bouton droit
|
||
de la souris
|
||
*/
|
||
{
|
||
wxPoint pos;
|
||
wxMenu MasterMenu;
|
||
|
||
pos.x = event.GetX(); pos.y = event.GetY();
|
||
m_Parent->OnRightClick(pos, &MasterMenu);
|
||
AddMenuZoom(&MasterMenu);
|
||
m_IgnoreMouseEvents = TRUE;
|
||
PopupMenu( &MasterMenu, pos);
|
||
MouseToCursorSchema();
|
||
m_IgnoreMouseEvents = FALSE;
|
||
}
|
||
|
||
|
||
/******************************************************/
|
||
void WinEDA_DrawPanel::OnMouseLeaving(wxMouseEvent& event)
|
||
/*******************************************************/
|
||
// Called when the canvas receives a mouse event leaving frame. //
|
||
{
|
||
if (ManageCurseur == NULL ) // Pas de commande encours
|
||
m_AutoPAN_Request = FALSE;
|
||
|
||
if ( ! m_AutoPAN_Enable || ! m_AutoPAN_Request || m_IgnoreMouseEvents)
|
||
return;
|
||
// Auto pan if mouse is leave working aera:
|
||
wxSize size = GetClientSize();
|
||
if ( (size.x < event.GetX() ) ||
|
||
(size.y < event.GetY() ) ||
|
||
( event.GetX() <= 0) || ( event.GetY() <= 0 ) )
|
||
m_Parent->OnZoom(ID_POPUP_ZOOM_CENTER);
|
||
}
|
||
|
||
|
||
/******************************************************/
|
||
void WinEDA_DrawPanel::OnMouseEvent(wxMouseEvent& event)
|
||
/*******************************************************/
|
||
// Called when the canvas receives a mouse event. //
|
||
{
|
||
int localrealbutt = 0, localbutt = 0, localkey = 0;
|
||
BASE_SCREEN * screen = GetScreen();
|
||
static WinEDA_DrawPanel * LastPanel;
|
||
|
||
if ( event.Leaving() || event.Entering() )
|
||
{
|
||
m_CanStartBlock = -1;
|
||
}
|
||
|
||
if (ManageCurseur == NULL ) // Pas de commande en cours
|
||
m_AutoPAN_Request = FALSE;
|
||
|
||
if ( m_Parent->m_FrameIsActive ) SetFocus();
|
||
else return;
|
||
|
||
// Mouse Wheel is a zoom command:
|
||
if ( event.m_wheelRotation )
|
||
{
|
||
// This is a zoom in ou out command
|
||
if ( event.GetWheelRotation() > 0 )
|
||
{
|
||
if( event.ShiftDown() ) localkey = EDA_PANNING_UP_KEY;
|
||
else if( event.ControlDown() ) localkey = EDA_PANNING_LEFT_KEY;
|
||
else localkey = WXK_F1;
|
||
}
|
||
else
|
||
{
|
||
if( event.ShiftDown() ) localkey = EDA_PANNING_DOWN_KEY;
|
||
else if( event.ControlDown() ) localkey = EDA_PANNING_RIGHT_KEY;
|
||
else localkey = WXK_F2;
|
||
}
|
||
}
|
||
|
||
if( !event.IsButton() && !event.Moving() &&
|
||
!event.Dragging() && ! localkey )
|
||
{
|
||
return;
|
||
}
|
||
|
||
if( event.RightDown() )
|
||
{
|
||
OnRightClick(event); return;
|
||
}
|
||
|
||
if ( m_IgnoreMouseEvents ) return;
|
||
|
||
if( event.LeftIsDown() ) localrealbutt |= GR_M_LEFT_DOWN;
|
||
if( event.MiddleIsDown() ) localrealbutt |= GR_M_MIDDLE_DOWN;
|
||
|
||
if( event.LeftDown()) localbutt = GR_M_LEFT_DOWN;
|
||
|
||
if( event.ButtonDClick(1)) localbutt = GR_M_LEFT_DOWN|GR_M_DCLICK;
|
||
if( event.MiddleDown()) localbutt = GR_M_MIDDLE_DOWN;
|
||
if( event.ButtonDClick(2)) {}; // Unused
|
||
|
||
|
||
localrealbutt |= localbutt; /* compensation defaut wxGTK */
|
||
|
||
/* Compute absolute m_MousePosition in pixel units: */
|
||
screen->m_MousePositionInPixels = CalcAbsolutePosition(wxPoint(event.GetX(), event.GetY()));
|
||
/* Compute absolute m_MousePosition in user units: */
|
||
screen->m_MousePosition = CursorRealPosition(screen->m_MousePositionInPixels);
|
||
|
||
wxClientDC DC(this);
|
||
int kbstat = 0;
|
||
|
||
DC.SetBackground(*wxBLACK_BRUSH );
|
||
PrepareGraphicContext(&DC);
|
||
|
||
g_KeyPressed = localkey;
|
||
|
||
if( event.ShiftDown() ) kbstat |= GR_KB_SHIFT;
|
||
if( event.ControlDown() ) kbstat |= GR_KB_CTRL;
|
||
if( event.AltDown() ) kbstat |= GR_KB_ALT;
|
||
|
||
g_MouseOldButtons = localrealbutt;
|
||
|
||
// Appel des fonctions li<6C>es au Double Click ou au Click
|
||
if( localbutt == (int)(GR_M_LEFT_DOWN|GR_M_DCLICK) )
|
||
m_Parent->OnLeftDClick(&DC, screen->m_MousePositionInPixels);
|
||
|
||
else if ( event.LeftDown() )
|
||
m_Parent->OnLeftClick(&DC, screen->m_MousePositionInPixels);
|
||
|
||
if( event.ButtonUp(2) && (screen->BlockLocate.m_State == STATE_NO_BLOCK) )
|
||
{ // The middle button has been relached, with no block command:
|
||
// We use it for a zoom center command
|
||
g_KeyPressed = localkey = WXK_F4;
|
||
}
|
||
|
||
|
||
/* Appel de la fonction generale de gestion des mouvements souris
|
||
et commandes clavier */
|
||
m_Parent->GeneralControle(&DC, screen->m_MousePositionInPixels);
|
||
|
||
|
||
/*******************************/
|
||
/* Control of block commands : */
|
||
/*******************************/
|
||
|
||
// Command block can't start if mouse is dragging a new panel
|
||
if (LastPanel != this ) m_CanStartBlock = -1;
|
||
|
||
// A new command block can start after a release buttons
|
||
// Avoid a false start block when a dialog bos is demiss,
|
||
// or when changing panels in hierachy navigation
|
||
if ( !event.LeftIsDown() && !event.MiddleIsDown())
|
||
{
|
||
m_CanStartBlock = 0;
|
||
}
|
||
|
||
if( m_Block_Enable && !(localbutt & GR_M_DCLICK) )
|
||
{
|
||
if ( (screen->BlockLocate.m_Command == BLOCK_IDLE) ||
|
||
(screen->BlockLocate.m_State == STATE_NO_BLOCK))
|
||
{
|
||
m_CursorStartPos = screen->m_Curseur;
|
||
screen->BlockLocate.SetOrigin(m_CursorStartPos);
|
||
}
|
||
if ( event.LeftDown() || event.MiddleDown() )
|
||
{
|
||
m_CursorStartPos = screen->m_Curseur;
|
||
if ( screen->BlockLocate.m_State == STATE_BLOCK_MOVE )
|
||
{
|
||
m_AutoPAN_Request = FALSE;
|
||
m_Parent->HandleBlockPlace(&DC);
|
||
}
|
||
}
|
||
else if( (m_CanStartBlock >= 0 ) &&
|
||
( event.LeftIsDown() || event.MiddleIsDown() )
|
||
&& ManageCurseur == NULL
|
||
&& ForceCloseManageCurseur == NULL )
|
||
{
|
||
if ( screen->BlockLocate.m_State == STATE_NO_BLOCK )
|
||
{
|
||
int cmd_type = kbstat;
|
||
if ( event.MiddleIsDown() ) cmd_type |= MOUSE_MIDDLE;
|
||
if ( ! m_Parent->HandleBlockBegin(&DC, cmd_type, m_CursorStartPos) )
|
||
{ // error
|
||
m_Parent->DisplayToolMsg( wxT("WinEDA_DrawPanel::OnMouseEvent() Block Error") );
|
||
}
|
||
else
|
||
{
|
||
m_AutoPAN_Request = TRUE;
|
||
SetCursor(m_PanelCursor = wxCURSOR_SIZING);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
if( event.ButtonUp(1) || event.ButtonUp(2) )
|
||
{ /* Relachement du bouton: fin de delimitation de block.
|
||
La commande peut etre terminee (DELETE) ou continuer par le placement
|
||
du block ainsi delimite (MOVE, COPY).
|
||
Cependant bloc est annule si sa taille est trop petite*/
|
||
bool BlockIsSmall =
|
||
( ABS(screen->BlockLocate.GetWidth()/GetZoom()) < 3) &&
|
||
( ABS(screen->BlockLocate.GetHeight()/GetZoom()) < 3);
|
||
|
||
if ( (screen->BlockLocate.m_State != STATE_NO_BLOCK) && BlockIsSmall )
|
||
{
|
||
if( ForceCloseManageCurseur )
|
||
{
|
||
ForceCloseManageCurseur(this, &DC);
|
||
m_AutoPAN_Request = FALSE;
|
||
}
|
||
SetCursor(m_PanelCursor = m_PanelDefaultCursor);
|
||
}
|
||
else if ( screen->BlockLocate.m_State == STATE_BLOCK_END )
|
||
{
|
||
m_AutoPAN_Request = FALSE;
|
||
m_Parent->HandleBlockEnd(&DC);
|
||
SetCursor(m_PanelCursor = m_PanelDefaultCursor);
|
||
if ( screen->BlockLocate.m_State == STATE_BLOCK_MOVE )
|
||
{
|
||
m_AutoPAN_Request = TRUE;
|
||
SetCursor(m_PanelCursor = wxCURSOR_HAND);
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
// Arret de block sur un double click ( qui peut provoquer un move block
|
||
// si on d<>place la souris dans ce double click
|
||
if ( localbutt == (int)(GR_M_LEFT_DOWN|GR_M_DCLICK) )
|
||
{
|
||
if ( screen->BlockLocate.m_Command != BLOCK_IDLE )
|
||
{
|
||
if( ForceCloseManageCurseur )
|
||
{
|
||
ForceCloseManageCurseur(this, &DC);
|
||
m_AutoPAN_Request = FALSE;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
#if 0
|
||
wxString msg_debug;
|
||
msg_debug.Printf(" block state %d, cmd %d",
|
||
screen->BlockLocate.m_State, screen->BlockLocate.m_Command);
|
||
m_Parent->PrintMsg(msg_debug);
|
||
#endif
|
||
|
||
LastPanel = this;
|
||
m_Parent->SetToolbars();
|
||
}
|
||
|
||
/****************************************************/
|
||
void WinEDA_DrawPanel::OnKeyEvent(wxKeyEvent& event)
|
||
/****************************************************/
|
||
{
|
||
long key, localkey;
|
||
bool escape = FALSE;
|
||
|
||
key = localkey = event.GetKeyCode();
|
||
|
||
switch( localkey )
|
||
{
|
||
case WXK_CONTROL:
|
||
case WXK_CAPITAL:
|
||
case WXK_SHIFT:
|
||
case WXK_NUMLOCK:
|
||
case WXK_LBUTTON:
|
||
case WXK_RBUTTON:
|
||
case 0x0135: /* Alt key */
|
||
return;
|
||
|
||
case WXK_ESCAPE:
|
||
escape = m_AbortRequest = TRUE;
|
||
break;
|
||
}
|
||
|
||
if( event.ControlDown() ) localkey |= GR_KB_CTRL;
|
||
if( event.AltDown() ) localkey |= GR_KB_ALT;
|
||
if( event.ShiftDown() && (key > 256) ) localkey |= GR_KB_SHIFT;
|
||
|
||
wxClientDC DC(this);
|
||
BASE_SCREEN * Screen = GetScreen();
|
||
|
||
PrepareGraphicContext(&DC);
|
||
|
||
g_KeyPressed = localkey;
|
||
|
||
if ( escape )
|
||
{
|
||
if( ManageCurseur && ForceCloseManageCurseur )
|
||
{
|
||
SetCursor(m_PanelCursor = m_PanelDefaultCursor);
|
||
ForceCloseManageCurseur(this, &DC);
|
||
SetCursor(m_PanelCursor = m_PanelDefaultCursor);
|
||
}
|
||
else m_Parent->SetToolID(0, m_PanelCursor = m_PanelDefaultCursor = wxCURSOR_ARROW, wxEmptyString);
|
||
}
|
||
|
||
m_Parent->GeneralControle(&DC, Screen->m_MousePositionInPixels);
|
||
|
||
#if 0
|
||
event.Skip(); // Allow menu shortcut processing
|
||
#endif
|
||
}
|
||
|
||
|
||
|