Mirrors
/
kicad
mirror of https://github.com/KiCad/kicad-source-mirror
3
0
Fork 0
Code Releases Activity
Browse Source

New zoom implementation and some build optimizations.

pull/1/head
stambaughw 17 years ago
parent
f1a37af8ff
commit
2e5a57e100
63 changed files with 1333 additions and 1251 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 9
      CHANGELOG.txt
  2. 182
      common/base_screen.cpp
  3. 5
      common/base_struct.cpp
  4. 24
      common/basicframe.cpp
  5. 10
      common/block_commande.cpp
  6. 14
      common/copy_to_clipboard.cpp
  7. 102
      common/drawframe.cpp
  8. 111
      common/drawpanel.cpp
  9. 12
      common/drawtxt.cpp
  10. 165
      common/edaappl.cpp
  11. 65
      common/gr_basic.cpp
  12. 145
      common/zoom.cpp
  13. 4
      cvpcb/displayframe.cpp
  14. 2
      eeschema/block.cpp
  15. 12
      eeschema/class_drawsheet.cpp
  16. 11
      eeschema/class_hierarchical_PIN_sheet.cpp
  17. 2
      eeschema/class_pin.cpp
  18. 14
      eeschema/class_screen.cpp
  19. 18
      eeschema/controle.cpp
  20. 2
      eeschema/dialog_SVG_print.cpp
  21. 1
      eeschema/dialog_print_using_printer.cpp
  22. 1
      eeschema/edit_graphic_bodyitem_text.cpp
  23. 1
      eeschema/eeconfig.cpp
  24. 2
      eeschema/eelibs_draw_components.cpp
  25. 29
      eeschema/eeredraw.cpp
  26. 1
      eeschema/erc.cpp
  27. 1
      eeschema/getpart.cpp
  28. 12
      eeschema/hierarch.cpp
  29. 1086
      eeschema/libedit.cpp
  30. 2
      eeschema/libframe.cpp
  31. 5
      eeschema/schframe.cpp
  32. 1
      eeschema/symbdraw.cpp
  33. 2
      eeschema/viewlib_frame.cpp
  34. 2
      eeschema/viewlibs.cpp
  35. 5
      gerbview/controle.cpp
  36. 24
      gerbview/gerberframe.cpp
  37. 1
      gerbview/tracepcb.cpp
  38. 94
      gerbview/trpiste.cpp
  39. 8
      include/appl_wxstruct.h
  40. 2
      include/base_struct.h
  41. 59
      include/drawpanel_wxstruct.h
  42. 1
      include/fctsys.h
  43. 23
      include/id.h
  44. 25
      include/wxstruct.h
  45. 5
      kicad/kicad.cpp
  46. 6
      pcbnew/basepcbframe.cpp
  47. 1
      pcbnew/block_module_editor.cpp
  48. 5
      pcbnew/class_cotation.cpp
  49. 89
      pcbnew/class_drawsegment.cpp
  50. 51
      pcbnew/class_edge_mod.cpp
  51. 3
      pcbnew/class_marker.cpp
  52. 5
      pcbnew/class_mire.cpp
  53. 3
      pcbnew/class_module.cpp
  54. 8
      pcbnew/class_pad_draw_functions.cpp
  55. 17
      pcbnew/class_text_mod.cpp
  56. 32
      pcbnew/class_track.cpp
  57. 2
      pcbnew/class_zone.h
  58. 14
      pcbnew/classpcb.cpp
  59. 4
      pcbnew/controle.cpp
  60. 15
      pcbnew/moduleframe.cpp
  61. 18
      pcbnew/pcbframe.cpp
  62. 4
      pcbnew/tool_modedit.cpp
  63. 5
      pcbnew/tool_pcb.cpp

9
CHANGELOG.txt
View File

@ -5,6 +5,15 @@ Started 2007-June-11
Please add newer entries at the top, list the date and your name with
email address.
2009-Jan-29 UPDATE Wayne Stambaugh <stambaughw@verizon.net>
================================================================================
++All
* Replace zoom implementation with a more flexible ( and hopefully useful )
design.
* Removed gr_basic.h from fctsys.h so that the entire project doesn't get
rebuilt unnecessarily.
2009-Jan-29 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================
++eeschema

182
common/base_screen.cpp
View File

@ -25,14 +25,14 @@ WX_DEFINE_OBJARRAY( GridArray );
BASE_SCREEN::BASE_SCREEN( KICAD_T aType ) : EDA_BaseStruct( aType )
{
EEDrawList = NULL; /* Schematic items list */
m_ZoomList = NULL;
m_UndoList = NULL;
m_RedoList = NULL;
m_UndoRedoCountMax = 1;
m_FirstRedraw = TRUE;
m_ScreenNumber = 1;
m_NumberOfScreen = 1; /* Hierarchy: Root: ScreenNumber = 1 */
m_Zoom = 32;
m_ZoomScalar = 10;
m_Zoom = 32 * m_ZoomScalar;
m_Grid = wxSize( 50, 50 ); /* Default grid size */
m_UserGridIsON = FALSE;
m_Diviseur_Grille = 1;
@ -47,9 +47,6 @@ BASE_SCREEN::BASE_SCREEN( KICAD_T aType ) : EDA_BaseStruct( aType )
BASE_SCREEN::~BASE_SCREEN()
/******************************/
{
if( m_ZoomList )
free( m_ZoomList );
ClearUndoRedoList();
}
@ -101,131 +98,174 @@ wxSize BASE_SCREEN::ReturnPageSize( void )
{
int internal_units = GetInternalUnits();
return wxSize( m_CurrentSheetDesc->m_Size.x * (internal_units / 1000),
m_CurrentSheetDesc->m_Size.y * (internal_units / 1000) );
return wxSize( ( m_CurrentSheetDesc->m_Size.x * internal_units ) / 1000,
( m_CurrentSheetDesc->m_Size.y * internal_units ) / 1000 );
}
/******************************************************************/
wxPoint BASE_SCREEN::CursorRealPosition( const wxPoint& ScreenPos )
/******************************************************************/
{
wxPoint curpos;
wxPoint curpos = ScreenPos;
Unscale( curpos );
// D(printf("curpos=%d,%d GetZoom=%d, mDrawOrg=%d,%d\n", curpos.x, curpos.y, GetZoom(), m_DrawOrg.x, m_DrawOrg.y );)
curpos.x = ScreenPos.x * GetZoom();
curpos.y = ScreenPos.y * GetZoom();
// curpos.x = Unscale( ScreenPos.x );
// curpos.y = Unscale( ScreenPos.y );
curpos.x += m_DrawOrg.x;
curpos.y += m_DrawOrg.y;
curpos += m_DrawOrg;
return curpos;
}
/**
* Calculate coordinate value for zooming.
*
* Call this method when drawing on the device context. It scales the
* coordinate using the current zoom settings. Zooming in Kicad occurs
* by actually scaling the entire drawing using the zoom setting.
*
* FIXME: We should probably use wxCoord instead of int here but that would
* require using wxCoord in all of the other code that makes device
* context calls as well.
*/
int BASE_SCREEN::Scale( int coord )
{
#ifdef WX_ZOOM
return coord;
#else
if( !m_Zoom )
return 0;
/**************************************************/
void BASE_SCREEN::SetZoomList( const int* zoomlist )
/**************************************************/
if( !m_ZoomScalar || !m_Zoom )
return 0;
/* init liste des zoom (NULL terminated)
return wxRound( (double) ( coord * m_ZoomScalar ) / (double) m_Zoom );
#endif
}
void BASE_SCREEN::Scale( wxPoint& pt )
{
pt.x = Scale( pt.x );
pt.y = Scale( pt.y );
}
void BASE_SCREEN::Scale( wxSize& sz )
{
sz.SetHeight( Scale( sz.GetHeight() ) );
sz.SetWidth( Scale( sz.GetWidth() ) );
}
/**
* Calculate the physical (unzoomed) location of a coordinate.
*
* Call this method when you want to find the unzoomed (physical) location
* of a coordinate on the drawing.
*/
int BASE_SCREEN::Unscale( int coord )
{
int nbitems;
const int* zoom;
#ifdef WX_ZOOM
return coord;
#else
if( !m_Zoom || !m_ZoomScalar )
return 0;
// get list length
for( nbitems = 1, zoom = zoomlist; ; zoom++, nbitems++ )
{
if( *zoom == 0 )
break;
}
return wxRound( (double) ( coord * m_Zoom ) / (double) m_ZoomScalar );
#endif
}
// resize our list
if( m_ZoomList )
free( m_ZoomList );
void BASE_SCREEN::Unscale( wxPoint& pt )
{
pt.x = Unscale( pt.x );
pt.y = Unscale( pt.y );
}
m_ZoomList = (int*) MyZMalloc( nbitems * sizeof(int) );
int ii;
for( ii = 0, zoom = zoomlist; ii < nbitems; zoom++, ii++ )
{
m_ZoomList[ii] = *zoom;
}
void BASE_SCREEN::Unscale( wxSize& sz )
{
sz.SetHeight( Unscale( sz.GetHeight() ) );
sz.SetWidth( Unscale( sz.GetWidth() ) );
}
void BASE_SCREEN::SetZoomList( const wxArrayInt& zoomlist )
{
if( !m_ZoomList.IsEmpty() )
m_ZoomList.Empty();
m_ZoomList = zoomlist;
}
/***********************************/
void BASE_SCREEN::SetFirstZoom()
/***********************************/
{
m_Zoom = 1;
if( m_ZoomList.IsEmpty() )
m_Zoom = m_ZoomScalar;
else
m_Zoom = m_ZoomList[0];
}
/******************************/
int BASE_SCREEN::GetZoom() const
/******************************/
{
return m_Zoom;
}
/***********************************/
void BASE_SCREEN::SetZoom( int coeff )
/***********************************/
{
m_Zoom = coeff;
if( m_Zoom < 1 )
m_Zoom = 1;
}
/********************************/
void BASE_SCREEN::SetNextZoom()
/********************************/
/* Selectionne le prochain coeff de zoom
*/
{
m_Zoom *= 2;
size_t i;
if( m_ZoomList == NULL )
if( m_ZoomList.IsEmpty() || m_Zoom >= m_ZoomList.Last() )
return;
int ii, zoom_max = 512;
for( ii = 0; m_ZoomList[ii] != 0; ii++ )
zoom_max = m_ZoomList[ii];
if( m_Zoom > zoom_max )
m_Zoom = zoom_max;
for( i = 0; i < m_ZoomList.GetCount(); i++ )
{
if( m_Zoom < m_ZoomList[i] )
{
m_Zoom = m_ZoomList[i];
break;
}
}
}
/*************************************/
void BASE_SCREEN::SetPreviousZoom()
/*************************************/
/* Selectionne le precedent coeff de zoom
*/
{
m_Zoom /= 2;
if( m_Zoom < 1 )
m_Zoom = 1;
size_t i;
if( m_ZoomList.IsEmpty() || m_Zoom <= m_ZoomList[0] )
return;
for( i = m_ZoomList.GetCount(); i != 0; i-- )
{
if( m_Zoom > m_ZoomList[i - 1] )
{
m_Zoom = m_ZoomList[i - 1];
break;
}
}
}
/**********************************/
void BASE_SCREEN::SetLastZoom()
/**********************************/
/* ajuste le coeff de zoom au max
*/
{
if( m_ZoomList == NULL )
if( m_ZoomList.IsEmpty() )
return;
int ii;
for( ii = 0; m_ZoomList[ii] != 0; ii++ )
m_Zoom = m_ZoomList[ii];
m_Zoom = m_ZoomList.Last();
}

5
common/base_struct.cpp
View File

@ -7,6 +7,7 @@
/* Fichier base_struct.cpp */
#include "fctsys.h"
#include "gr_basic.h"
#include "trigo.h"
#include "common.h"
#include "wxstruct.h"
@ -272,10 +273,8 @@ void EDA_TextStruct::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
* @param EDA_Colors aAnchor_color = anchor color ( UNSPECIFIED_COLOR = do not draw anchor ).
*/
{
int zoom;
int width;
zoom = aPanel->GetZoom();
width = m_Width;
if( aDisplayMode == FILAIRE )
width = 0;
@ -286,7 +285,7 @@ void EDA_TextStruct::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
/* Draw text anchor, if allowed */
if( aAnchor_color != UNSPECIFIED_COLOR )
{
int anchor_size = 2 * zoom;
int anchor_size = aPanel->GetScreen()->Unscale( 2 );
aAnchor_color = (EDA_Colors) (aAnchor_color & MASKCOLOR);
int cX = m_Pos.x + aOffset.x;

24
common/basicframe.cpp
View File

@ -209,6 +209,7 @@ wxString WinEDA_BasicFrame::GetFileFromHistory( int cmdId,
void WinEDA_BasicFrame::GetKicadHelp( wxCommandEvent& event )
/**************************************************************/
{
wxString msg;
#if defined ONLINE_HELP_FILES_FORMAT_IS_HTML
if( wxGetApp().m_HtmlCtrl == NULL )
{
@ -223,19 +224,28 @@ void WinEDA_BasicFrame::GetKicadHelp( wxCommandEvent& event )
}
else
{
wxString msg;
msg.Printf( _( "Help file %s not found" ), wxGetApp().m_HelpFileName.GetData() );
DisplayError( this, msg );
}
#elif defined ONLINE_HELP_FILES_FORMAT_IS_PDF
wxString fullfilename = FindKicadHelpPath() + wxGetApp().m_HelpFileName;
if ( wxFileExists(fullfilename) )
GetAssociatedDocument( this, wxEmptyString, fullfilename );
else // Try to find file in English format:
// wxString fullfilename = FindKicadHelpPath() + wxGetApp().m_HelpFileName;
// if ( wxFileExists(fullfilename) )
// GetAssociatedDocument( this, wxEmptyString, fullfilename );
// else // Try to find file in English format:
// {
// fullfilename = FindKicadHelpPath() + wxT("../en/") + wxGetApp().m_HelpFileName;;
// GetAssociatedDocument( this, wxEmptyString, fullfilename );
// }
wxString helpFile = wxGetApp().GetHelpFile();
if( !helpFile )
{
fullfilename = FindKicadHelpPath() + wxT("../en/") + wxGetApp().m_HelpFileName;;
GetAssociatedDocument( this, wxEmptyString, fullfilename );
msg.Printf( _( "Help file %s could not be found." ),
wxGetApp().m_HelpFileName.c_str() );
DisplayError( this, msg );
}
else
GetAssociatedDocument( this, wxEmptyString, helpFile );
#else
#error Help files format not defined

10
common/block_commande.cpp
View File

@ -110,8 +110,8 @@ void DrawBlockStruct::SetMessageBlock( WinEDA_DrawFrame* frame )
void DrawBlockStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC )
/**************************************************************/
{
int w = GetWidth() / panel->GetZoom();
int h = GetHeight() / panel->GetZoom();
int w = panel->GetScreen()->Scale( GetWidth() );
int h = panel->GetScreen()->Scale( GetHeight() );
if( w == 0 || h == 0 )
GRLine( &panel->m_ClipBox, DC, GetX(), GetY(),
@ -133,8 +133,8 @@ bool WinEDA_DrawFrame::HandleBlockBegin( wxDC* DC, int key,
{
DrawBlockStruct* Block = & GetBaseScreen()->BlockLocate;
if( (Block->m_Command != BLOCK_IDLE)
|| ( Block->m_State != STATE_NO_BLOCK) )
if( ( Block->m_Command != BLOCK_IDLE )
|| ( Block->m_State != STATE_NO_BLOCK ) )
return FALSE;
Block->m_Flags = 0;
@ -177,7 +177,7 @@ bool WinEDA_DrawFrame::HandleBlockBegin( wxDC* DC, int key,
{
Block->m_BlockDrawStruct = NULL;
DisplayError( this,
wxT( "WinEDA_DrawFrame::HandleBlockBegin() Err: ManageCurseur NULL" ) );
wxT( "WinEDA_DrawFrame::HandleBlockBegin() Err: ManageCurseur NULL" ) );
return TRUE;
}
Block->m_State = STATE_BLOCK_MOVE;

14
common/copy_to_clipboard.cpp
View File

@ -5,21 +5,9 @@
// Created: 18 aug 2006
// Licence: License GNU
/////////////////////////////////////////////////////////////////////////////
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
#include <ctype.h>
#include "wx/metafile.h"
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "id.h"

102
common/drawframe.cpp
View File

@ -7,6 +7,7 @@
#endif
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "bitmaps.h"
#include "macros.h"
@ -36,32 +37,30 @@ WinEDA_DrawFrame::WinEDA_DrawFrame( wxWindow* father, int idtype,
{
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_VToolBar = NULL;
m_AuxVToolBar = NULL;
m_OptionsToolBar = NULL;
m_AuxiliaryToolBar = NULL;
m_SelGridBox = NULL;
m_SelZoomBox = NULL;
DrawPanel = NULL;
MsgPanel = NULL;
m_CurrentScreen = NULL;
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�
m_Print_Sheet_Ref = TRUE; // TRUE pour avoir le cartouche imprim�
m_Draw_Auxiliary_Axis = FALSE; // TRUE pour avoir les axes auxiliares dessines
m_UnitType = INTERNAL_UNIT_TYPE; // Internal unit = inch
// Internal units per inch
// = 1000 for schema, = 10000 for PCB
m_InternalUnits = EESCHEMA_INTERNAL_UNIT;
minsize.x = 470;
minsize.y = 350 + m_MsgFrameHeight;
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�
m_Print_Sheet_Ref = TRUE; // TRUE pour avoir le cartouche imprim�
m_Draw_Auxiliary_Axis = FALSE; // TRUE pour avoir les axes auxiliares dessines
m_UnitType = INTERNAL_UNIT_TYPE; // Internal unit = inch
// Internal units per inch: = 1000 for schema, = 10000 for PCB
m_InternalUnits = EESCHEMA_INTERNAL_UNIT;
minsize.x = 470;
minsize.y = 350 + m_MsgFrameHeight;
SetSizeHints( minsize.x, minsize.y, -1, -1, -1, -1 );
/* Verification des parametres de creation */
@ -267,42 +266,37 @@ void WinEDA_DrawFrame::OnSelectGrid( wxCommandEvent& event )
}
/********************************************************/
void WinEDA_DrawFrame::OnSelectZoom( wxCommandEvent& event ) // fonction virtuelle
/********************************************************/
/* Set the zoom when selected by the Zoom List Box
/**
* 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
* virtual function
*/
void WinEDA_DrawFrame::OnSelectZoom( wxCommandEvent& event )
{
if( m_SelZoomBox == NULL )
return; //Ne devrait pas se produire!
int id = m_SelZoomBox->GetChoice();
if( id < 0 )
return; // No selection
if( id < 0 || !( id < (int)m_SelZoomBox->GetCount() ) )
return;
if( id == 0 ) // Auto zoom (Fit in Page)
{
Zoom_Automatique( TRUE );
Zoom_Automatique( true );
}
else if( id == (int) (m_SelZoomBox->GetCount() - 1) ) // Dummy position: unlisted zoom
return;
else // zooml 1 to zoom max
else
{
id--;
int zoom = 1 << id;
if( zoom > m_ZoomMaxValue )
zoom = m_ZoomMaxValue;
if( GetBaseScreen()->GetZoom() == zoom )
int selectedZoom = GetBaseScreen()->m_ZoomList[id];
if( GetBaseScreen()->GetZoom() == selectedZoom )
return;
GetBaseScreen()->m_Curseur = DrawPanel->GetScreenCenterRealPosition();
GetBaseScreen()->SetZoom( zoom );
Recadre_Trace( FALSE );
GetBaseScreen()->SetZoom( selectedZoom );
Recadre_Trace( false );
}
}
@ -569,14 +563,11 @@ int WinEDA_DrawFrame::HandleBlockEnd( wxDC* DC )
void WinEDA_DrawFrame::AdjustScrollBars()
/*********************************************/
{
int xUnit, yUnit;
wxSize draw_size, panel_size;
wxSize scrollbar_number;
wxPoint scrollbar_pos;
BASE_SCREEN* screen = GetBaseScreen();
int zoom = screen->GetZoom();
int xUnit, yUnit;
BASE_SCREEN* screen = GetBaseScreen();
if( screen == NULL || DrawPanel == NULL )
return;
@ -586,7 +577,8 @@ void WinEDA_DrawFrame::AdjustScrollBars()
// On utilise le centre de l'ecran comme position de reference, donc
// la surface de trace doit etre augmentee
panel_size = DrawPanel->GetClientSize() * zoom;
panel_size = DrawPanel->GetClientSize();
screen->Unscale( panel_size );
draw_size += panel_size / 2;
@ -606,20 +598,18 @@ void WinEDA_DrawFrame::AdjustScrollBars()
screen->m_DrawOrg.y -= screen->m_DrawOrg.y % 256;
// Calcul du nombre de scrolls (en unites de scrool )
scrollbar_number = draw_size / (DrawPanel->m_Scroll_unit * zoom);
xUnit = yUnit = DrawPanel->m_Scroll_unit;
scrollbar_number = draw_size / screen->Unscale( screen->m_ZoomScalar );
xUnit = yUnit = screen->m_ZoomScalar;
if( xUnit <= 1 )
xUnit = 1;
if( yUnit <= 1 )
yUnit = 1;
xUnit *= zoom;
yUnit *= zoom;
xUnit = screen->Unscale( xUnit );
yUnit = screen->Unscale( yUnit );
// Calcul de la position, curseur place au centre d'ecran
scrollbar_pos = screen->m_Curseur;
scrollbar_pos -= screen->m_DrawOrg;
scrollbar_pos = screen->m_Curseur - screen->m_DrawOrg;
scrollbar_pos.x -= panel_size.x / 2;
scrollbar_pos.y -= panel_size.y / 2;
@ -634,8 +624,8 @@ void WinEDA_DrawFrame::AdjustScrollBars()
screen->m_ScrollbarPos = scrollbar_pos;
screen->m_ScrollbarNumber = scrollbar_number;
DrawPanel->SetScrollbars( DrawPanel->m_Scroll_unit,
DrawPanel->m_Scroll_unit,
DrawPanel->SetScrollbars( screen->m_ZoomScalar,
screen->m_ZoomScalar,
screen->m_ScrollbarNumber.x,
screen->m_ScrollbarNumber.y,
screen->m_ScrollbarPos.x,

111
common/drawpanel.cpp
View File

@ -2,6 +2,7 @@
/* drawpanel.cpp - WinEDA_DrawPanel class */
/******************************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "macros.h"
@ -48,7 +49,6 @@ WinEDA_DrawPanel::WinEDA_DrawPanel( WinEDA_DrawFrame* parent, int id,
wxBORDER | wxNO_FULL_REPAINT_ON_RESIZE )
{
m_Parent = parent;
m_Scroll_unit = 1;
m_ScrollButt_unit = 40;
SetBackgroundColour( wxColour( ColorRefs[g_DrawBgColor].m_Red,
@ -89,13 +89,12 @@ BASE_SCREEN* WinEDA_DrawPanel::GetScreen()
}
/*********************************************************************************/
void WinEDA_DrawPanel::Trace_Curseur( wxDC* DC, int color )
/*********************************************************************************/
/*
/*****************************************************************************
*
* Draw the schematic cursor which is usually on grid
*/
*
*****************************************************************************/
void WinEDA_DrawPanel::Trace_Curseur( wxDC* DC, int color )
{
if( m_CursorLevel != 0 || DC == NULL )
return;
@ -105,9 +104,8 @@ void WinEDA_DrawPanel::Trace_Curseur( wxDC* DC, int color )
GRSetDrawMode( DC, GR_XOR );
if( g_CursorShape == 1 ) /* Trace d'un reticule */
{
int dx = m_ClipBox.GetWidth() * GetZoom();
int dy = m_ClipBox.GetHeight() * GetZoom();
int dx = GetScreen()->Unscale( m_ClipBox.GetWidth() );
int dy = GetScreen()->Unscale( m_ClipBox.GetHeight() );
GRLine( &m_ClipBox, DC, Cursor.x - dx, Cursor.y,
Cursor.x + dx, Cursor.y, 0, color ); // axe Y
@ -116,7 +114,7 @@ void WinEDA_DrawPanel::Trace_Curseur( wxDC* DC, int color )
}
else
{
int len = CURSOR_SIZE * GetZoom();
int len = GetScreen()->Unscale( CURSOR_SIZE );
GRLine( &m_ClipBox, DC, Cursor.x - len, Cursor.y,
Cursor.x + len, Cursor.y, 0, color );
@ -186,11 +184,9 @@ 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 );
double scale = 1.0 / (double) GetZoom();
DC->SetUserScale( scale, scale );
DoPrepareDC( *DC );
#endif
SetBoundaryBox();
}
@ -233,16 +229,10 @@ bool WinEDA_DrawPanel::IsPointOnDisplay( wxPoint ref_pos )
// Conversion en coord physiques
pos = CalcUnscrolledPosition( display_rect.GetPosition() );
pos.x *= GetZoom();
pos.y *= GetZoom();
GetScreen()->Unscale( pos );
pos += GetScreen()->m_DrawOrg;
display_rect.SetX( pos.x );
display_rect.SetY( pos.y );
display_rect.SetWidth( display_rect.GetWidth() * GetZoom() );
display_rect.SetHeight( display_rect.GetHeight() * GetZoom() );
display_rect.m_Pos = pos;
GetScreen()->Unscale( display_rect.m_Size );
return display_rect.Inside( ref_pos );
}
@ -277,11 +267,8 @@ void WinEDA_DrawPanel::ConvertPcbUnitsToPixelsUnits( EDA_Rect* aRect )
wxPoint pos = aRect->GetPosition();
ConvertPcbUnitsToPixelsUnits( &pos );
aRect->SetOrigin( pos ); // rect origin in pixel units
aRect->m_Size.x /= GetZoom();
aRect->m_Size.y /= GetZoom(); // size in pixel units
GetScreen()->Scale( aRect->m_Size );
}
@ -302,8 +289,7 @@ void WinEDA_DrawPanel::ConvertPcbUnitsToPixelsUnits( wxPoint* aPosition )
drwOrig.y *= y_axis_scale;
// Origin in internal units
drwOrig.x *= GetZoom();
drwOrig.y *= GetZoom();
GetScreen()->Unscale( drwOrig );
// Real origin, according to the "plot" origin
drwOrig += GetScreen()->m_DrawOrg;
@ -312,8 +298,7 @@ void WinEDA_DrawPanel::ConvertPcbUnitsToPixelsUnits( wxPoint* aPosition )
*aPosition -= drwOrig;
// position in pixels, relative to the visible draw area origin
aPosition->x /= GetZoom();
aPosition->y /= GetZoom();
GetScreen()->Scale( *aPosition );
}
@ -325,14 +310,10 @@ wxPoint WinEDA_DrawPanel::CursorScreenPosition()
* @return the curseur position in pixels in the panel draw area on screen )
*/
{
wxPoint curpos = GetScreen()->m_Curseur;
curpos -= GetScreen()->m_DrawOrg;
curpos.x /= GetZoom();
curpos.y /= GetZoom();
return curpos;
wxPoint pos = GetScreen()->m_Curseur;
pos -= GetScreen()->m_DrawOrg;
GetScreen()->Scale( pos );
return pos;
}
@ -350,9 +331,7 @@ wxPoint WinEDA_DrawPanel::GetScreenCenterRealPosition( void )
size = GetClientSize() / 2;
realpos = CalcUnscrolledPosition( wxPoint( size.x, size.y ) );
realpos.x *= GetZoom();
realpos.y *= GetZoom();
GetScreen()->Unscale( realpos );
realpos += GetScreen()->m_DrawOrg;
return realpos;
@ -381,7 +360,6 @@ void WinEDA_DrawPanel::MouseTo( const wxPoint& Mouse )
*/
{
wxPoint mouse;
#ifdef WX_ZOOM
CalcScrolledPosition( Mouse.x, Mouse.y, &mouse.x, &mouse.y );
#else
@ -483,9 +461,7 @@ void WinEDA_DrawPanel::SetBoundaryBox()
wxPoint org;
int ii, jj;
Screen->m_SizeVisu = GetClientSize();
GetViewStart( &org.x, &org.y );
GetScrollPixelsPerUnit( &ii, &jj );
org.x *= ii;
org.y *= jj;
@ -496,9 +472,8 @@ void WinEDA_DrawPanel::SetBoundaryBox()
m_ClipBox.SetSize( GetClientSize() );
#ifdef WX_ZOOM
m_ClipBox.m_Pos.x *= GetZoom();
m_ClipBox.m_Pos.y *= GetZoom();
m_ClipBox.m_Size *= GetZoom();
CalcUnscrolledPosition( m_ClipBox.m_Pos.x, m_ClipBox.m_Pos.y,
&m_ClipBox.m_Pos.x, &m_ClipBox.m_Pos.y );
#else
m_ClipBox.m_Pos -= GetScreen()->m_StartVisu;
#endif
@ -569,14 +544,12 @@ void WinEDA_DrawPanel::OnPaint( wxPaintEvent& event )
);
#endif
PaintClipBox.x += org.x;
PaintClipBox.y += org.y;
PaintClipBox.Offset( org );
#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.width * GetZoom();
m_ClipBox.m_Size.y = PaintClipBox.height * GetZoom();
BASE_SCREEN* screen = GetScreen();
screen->Unscale( m_ClipBox.m_Pos );
screen->Unscale( m_ClipBox.m_Size );
#else
m_ClipBox.SetX( PaintClipBox.GetX() );
m_ClipBox.SetY( PaintClipBox.GetY() );
@ -636,9 +609,8 @@ void WinEDA_DrawPanel::ReDraw( wxDC* DC, bool erasebg )
}
#ifdef WX_ZOOM
int zoom = GetZoom();
double f_scale = 1.0 / (double) zoom;
DC->SetUserScale( f_scale, f_scale );
double scale = 1.0 / (double) GetZoom();
DC->SetUserScale( scale, scale );
#endif
if( erasebg )
@ -675,7 +647,6 @@ void WinEDA_DrawPanel::DrawBackGround( wxDC* DC )
int ii, jj, xg, yg, color;
wxSize pas_grille_affichee;
bool drawgrid = FALSE;
int zoom = GetZoom();
wxSize size;
wxPoint org;
double pasx, pasy;
@ -691,7 +662,7 @@ void WinEDA_DrawPanel::DrawBackGround( wxDC* DC )
pas_grille_affichee = screen->GetGrid();
ii = pas_grille_affichee.x / zoom;
ii = screen->Scale( pas_grille_affichee.x );
if( ii < 5 )
{
pas_grille_affichee.x *= 2;
@ -700,7 +671,7 @@ void WinEDA_DrawPanel::DrawBackGround( wxDC* DC )
if( ii < 5 )
drawgrid = FALSE; // The gris is small
ii = pas_grille_affichee.y / zoom;
ii = screen->Scale( pas_grille_affichee.y );
if( ii < 5 )
{
pas_grille_affichee.y *= 2;
@ -711,18 +682,18 @@ void WinEDA_DrawPanel::DrawBackGround( wxDC* DC )
GetViewStart( &org.x, &org.y );
GetScrollPixelsPerUnit( &ii, &jj );
wxLogDebug( _T( "View start: %d, %d, scroll bar PPI: %d, %d" ),
org.x, org.y, ii, jj );
org.x *= ii;
org.y *= jj;
screen->m_StartVisu = org;
org.x *= zoom;
org.y *= zoom;
wxLogDebug( _T( "Scroll bar drawing position: %d. %d" ), org.x, org.y );
screen->Unscale( org );
org += screen->m_DrawOrg;
size = GetClientSize() * zoom;
size = GetClientSize();
screen->Unscale( size );
pasx = screen->m_Grid.x * m_Parent->m_InternalUnits;
pasy = screen->m_Grid.y * m_Parent->m_InternalUnits;
@ -1139,8 +1110,8 @@ void WinEDA_DrawPanel::OnMouseEvent( wxMouseEvent& event )
*/
#define BLOCK_MINSIZE_LIMIT 1
bool BlockIsSmall =
( ABS( screen->BlockLocate.GetWidth() / GetZoom() ) < BLOCK_MINSIZE_LIMIT)
&& ( ABS( screen->BlockLocate.GetHeight() / GetZoom() ) < BLOCK_MINSIZE_LIMIT);
( ABS( screen->Scale( screen->BlockLocate.GetWidth() ) ) < BLOCK_MINSIZE_LIMIT)
&& ( ABS( screen->Scale( screen->BlockLocate.GetHeight() ) ) < BLOCK_MINSIZE_LIMIT);
if( (screen->BlockLocate.m_State != STATE_NO_BLOCK) && BlockIsSmall )
{

12
common/drawtxt.cpp
View File

@ -51,7 +51,6 @@ void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* DC,
{
int ii, kk, char_count, AsciiCode, endcar;
int x0, y0;
int zoom;
int size_h, size_v, pitch;
SH_CODE f_cod, plume = 'U';
const SH_CODE* ptcar;
@ -63,11 +62,6 @@ void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* DC,
bool sketch_mode = false;
bool italic_reverse = false; // true for mirrored texts with m_Size.x < 0
if ( aPanel )
zoom = aPanel->GetZoom();
else
zoom = 1;
size_h = aSize.x;
size_v = aSize.y;
@ -101,7 +95,7 @@ void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* DC,
{
int xm, ym, ll, xc, yc;
int textsize = ABS( pitch );
ll = (textsize * char_count) / zoom;
ll = aPanel->GetScreen()->Scale( textsize * char_count );
xc = GRMapX( cX );
yc = GRMapY( cY );
@ -195,10 +189,10 @@ void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* DC,
ox = cX - dx;
oy = cY + dy;
if( (aSize.x / zoom) == 0 )
if( aPanel->GetScreen()->Scale( aSize.x ) == 0 )
return;
if( ABS( (aSize.x / zoom) ) < 3 ) /* shapes are too small: connot be drawn */
if( ABS( (aPanel->GetScreen()->Scale( aSize.x ) ) ) < 3 ) /* shapes are too small: connot be drawn */
{ /* insteed the text is drawn as a line */
dx = (pitch * char_count) / 2;
dy = size_v / 2; /* line is always centered */

165
common/edaappl.cpp
View File

@ -15,6 +15,7 @@
#endif
#include "fctsys.h"
#include "gr_basic.h"
#include "wx/html/htmlwin.h"
#include "wx/fs_zip.h"
#include <wx/dir.h>
@ -221,8 +222,8 @@ WinEDA_App::WinEDA_App()
m_EDA_Config = NULL;
m_Env_Defined = FALSE;
m_LanguageId = wxLANGUAGE_DEFAULT;
m_Locale = NULL;
m_PdfBrowserIsDefault = TRUE;
m_Locale = NULL;
}
@ -317,6 +318,7 @@ void WinEDA_App::InitEDA_Appl( const wxString& name )
// Analyse the command line & init binary path
SetBinDir();
SetDefaultSearchPaths();
SetLanguagePath();
ReadPdfBrowserInfos();
// Internationalisation: loading the kicad suitable Dictionnary
@ -441,6 +443,10 @@ bool WinEDA_App::SetBinDir()
while( m_BinDir.Last() != '/' )
m_BinDir.RemoveLast();
wxFileName pfn( wxT( "/posix/path/specification" ), wxT( "filename" ) );
wxFileName wfn( wxT( "\\windows\\path\\specification" ), wxT( "filename" ) );
wxLogDebug( wxT( "Posix path: " ) + pfn.GetFullPath() );
wxLogDebug( wxT( "Windows path: " ) + wfn.GetFullPath() );
wxLogDebug( wxT( "Executable path the Kicad way: " ) + m_BinDir );
wxLogDebug( wxT( "Executable path the wxWidgets way: " ) +
GetTraits()->GetStandardPaths().GetExecutablePath() );
@ -457,24 +463,22 @@ void WinEDA_App::SetDefaultSearchPaths( void )
wxString path;
wxFileName fn( m_BinDir, wxEmptyString );
/* User environment variable path. */
if( ::wxGetEnv( wxT( "KICAD_SEARCH_PATH" ), NULL ) )
m_searchPaths.AddEnvList( wxT( "KICAD_SEARCH_PATH" ) );
/* User environment variable path is the first search path. Chances are
* if the user is savvy enough to set an environment variable they know
* what they are doing. */
if( ::wxGetEnv( wxT( "KICAD" ), NULL ) )
m_searchPaths.AddEnvList( wxT( "KICAD" ) );
/* Hard coded path defined by the application. */
m_searchPaths.Add( ReturnKicadDatasPath() );
/* Add the user's home path. */
m_searchPaths.Add( GetTraits()->GetStandardPaths().GetUserDataDir() );
/* Standard application data path if it is different from the binary
* path. */
if( fn.GetPath() != GetTraits()->GetStandardPaths().GetDataDir() )
m_searchPaths.Add( GetTraits()->GetStandardPaths().GetDataDir() );
/* Up on level relative to binary path with "share" appended. */
/* Up on level relative to binary path with "share" appended for Windows. */
fn.RemoveLastDir();
fn.AppendDir( wxT( "share" ) );
#ifndef __WXMSW__
fn.AppendDir( wxT( "kicad" ) );
#endif
m_searchPaths.Add( fn.GetPath() );
/* Remove all non-existant paths from the list. */
@ -657,38 +661,23 @@ void WinEDA_App::SaveSettings()
bool WinEDA_App::SetLanguage( bool first_time )
/*********************************************/
{
size_t i;
wxString path;
bool retv = true;
// dictionary file name without extend (full name is kicad.mo)
wxString DictionaryName( wxT( "kicad" ) );
if( m_Locale != NULL )
if( m_Locale )
delete m_Locale;
m_Locale = new wxLocale();
/* Add defined search paths to locale paths */
if( !m_searchPaths.IsEmpty() )
{
for( i = 0; i < m_searchPaths.GetCount(); i++ )
{
wxFileName fn( m_searchPaths[i], wxEmptyString );
fn.AppendDir( wxT( "internat" ) );
path = fn.GetPath();
wxLogDebug( wxT( "Adding locale lookup path: " ) + path );
m_Locale->AddCatalogLookupPathPrefix( path );
}
}
m_Locale = new wxLocale;
if( !m_Locale->Init( m_LanguageId, wxLOCALE_CONV_ENCODING ) )
{
wxLogDebug( wxT( "Failed to initialize " ) +
wxLocale::GetLanguageInfo( m_LanguageId )->Description );
delete m_Locale;
m_Locale = new wxLocale();
m_LanguageId = wxLANGUAGE_DEFAULT;
delete m_Locale;
m_Locale = new wxLocale;
m_Locale->Init();
retv = false;
}
@ -732,6 +721,35 @@ void WinEDA_App::SetLanguageIdentifier( int menu_id )
}
void WinEDA_App::SetLanguagePath( void )
{
size_t i;
/* Add defined search paths to locale paths */
if( !m_searchPaths.IsEmpty() )
{
for( i = 0; i < m_searchPaths.GetCount(); i++ )
{
wxFileName fn( m_searchPaths[i], wxEmptyString );
fn.AppendDir( wxT( "share" ) );
#ifndef __WXMSW__
/* Up on level relative to binary path with "share/kicad" appended
* for all other platforms. */
fn.AppendDir( wxT( "kicad" ) );
#endif
fn.AppendDir( wxT( "internat" ) );
if( fn.DirExists() )
{
wxLogDebug( wxT( "Adding locale lookup path: " ) +
fn.GetPath() );
wxLocale::AddCatalogLookupPathPrefix( fn.GetPath() );
}
}
}
}
/** Function AddMenuLanguageList
* Create menu list for language choice, and add it as submenu to a main menu
* @param MasterMenu : The main menu. The sub menu list will be accessible from the menu item with id ID_LANGUAGE_CHOICE
@ -782,6 +800,93 @@ void WinEDA_App::AddMenuLanguageList( wxMenu* MasterMenu )
}
/**
* Look in search paths for requested file.
*
*/
wxString WinEDA_App::FindFileInSearchPaths( const wxString& filename,
const wxArrayString* subdirs )
{
size_t i, j;
wxFileName fn;
wxPathList paths;
for( i = 0; i < m_searchPaths.GetCount(); i++ )
{
fn = wxFileName( m_searchPaths[i], wxEmptyString );
if( subdirs )
{
for( j = 0; j < subdirs->GetCount(); j++ )
fn.AppendDir( subdirs->Item( j ) );
}
if( fn.DirExists() )
{
wxLogDebug( _T( "Adding <" ) + fn.GetPath() + _T( "> to " ) +
_T( "file \"" ) + filename + _T( "\" search path." ) );
paths.Add( fn.GetPath() );
}
}
return paths.FindValidPath( filename );
}
/**
* Get the help file path.
*
* Return the Kicad help file with path. The base paths defined in
* m_searchPaths are tested for a valid file. The path returned can
* be relative depending on the paths added to m_searchPaths. See the
* documentation for wxPathList for more information. If the help file
* for the current locale is not found, an attempt to find the English
* version of the help file is made. wxEmptyString is returned if the
* help file is not found.
*/
wxString WinEDA_App::GetHelpFile( void )
{
wxString fn;
wxArrayString subdirs;
/* FIXME: This is not the ideal way to handle this. Unfortunely, the
* CMake install paths seem to be a moving target so this crude
* hack solve the problem of install path differences between
* Windows and non-Windows platforms. */
#ifndef __WXMSW__
subdirs.Add( wxT( "share" ) );
#endif
subdirs.Add( _T( "doc" ) );
#ifndef __WXMSW__
subdirs.Add( wxT( "kicad" ) );
#endif
subdirs.Add( _T( "help" ) );
subdirs.Add( m_Locale->GetCanonicalName() );
fn = FindFileInSearchPaths( m_HelpFileName, &subdirs );
if( !fn && m_Locale->GetCanonicalName() != wxLocale::GetLanguageInfo(wxLANGUAGE_ENGLISH )->CanonicalName )
{
subdirs.RemoveAt( subdirs.GetCount() - 1 );
subdirs.Add( _T( "en" ) );
fn = FindFileInSearchPaths( m_HelpFileName, &subdirs );
}
return fn;
}
wxString WinEDA_App::GetLibraryFile( const wxString& filename )
{
wxArrayString subdirs;
subdirs.Add( wxT( "share" ) );
#ifndef __WXMSW__
/* Up on level relative to binary path with "share/kicad" appended for
* all other platforms. */
subdirs.Add( wxT( "kicad" ) );
#endif
return FindFileInSearchPaths( filename, &subdirs );
}
/**
* Run init scripts
* @return the defualt OnRun() value (exit codes not used in kicad, so value has no special mening)

65
common/gr_basic.cpp
View File

@ -18,21 +18,21 @@
extern BASE_SCREEN* ActiveScreen;
/* Variables locales */
static int GRLastMoveToX, GRLastMoveToY;
static int Text_Color = LIGHTGRAY;
static int PenMinWidth = 1;/* largeur minimum de la plume (DOIT etre > 0)
* (utile pour trace sur imprimante) */
static int ForceBlackPen;/* si != 0 : traces en noir (utilise pour trace
* sur imprimante */
static int xcliplo = 0,
ycliplo = 0,
xcliphi = 2000,
ycliphi = 2000;/* coord de la surface de trace */
static int lastcolor = -1;
static int lastwidth = -1;
static int GRLastMoveToX, GRLastMoveToY;
static int Text_Color = LIGHTGRAY;
static int PenMinWidth = 1; /* largeur minimum de la plume (DOIT etre > 0)
* (utile pour trace sur imprimante) */
static int ForceBlackPen; /* si != 0 : traces en noir (utilise pour trace
* sur imprimante */
static int xcliplo = 0,
ycliplo = 0,
xcliphi = 2000,
ycliphi = 2000; /* coord de la surface de trace */
static int lastcolor = -1;
static int lastwidth = -1;
static int s_Last_Pen_Style = -1;
static wxDC* lastDC = NULL;
static wxDC* lastDC = NULL;
/*
* Macro de clipping du trace d'une ligne:
@ -47,27 +47,18 @@ static wxDC* lastDC = NULL;
static inline int USCALE( us arg, us num, us den )
{
#ifndef WX_ZOOM
int ii;
ii = (int) ( ( (float) arg * num ) / den );
return ii;
}
#ifdef WX_ZOOM
#define GET_ZOOM 1
#else
#define GET_ZOOM ActiveScreen->GetZoom()
return arg;
#endif
}
static int inline ZoomValue( int value_to_zoom ) {
int zoom = GET_ZOOM;
if( !zoom ) return 0;
if( value_to_zoom >= 0 )
return ( value_to_zoom + (zoom >> 1 ) ) / zoom;
else
return ( value_to_zoom - (zoom >> 1 ) ) / zoom;
static int inline ZoomValue( int val )
{
return ActiveScreen->Scale( val );
}
/****************************************/
@ -75,27 +66,27 @@ static int inline ZoomValue( int value_to_zoom ) {
/****************************************/
int GRMapX( int x )
{
int coord = x - ActiveScreen->m_DrawOrg.x;
#ifndef WX_ZOOM
int coord = x - ActiveScreen->m_DrawOrg.x;
coord = ZoomValue( coord );
coord -= ActiveScreen->m_StartVisu.x;
#endif
return coord;
#else
return x;
#endif
}
int GRMapY( int y )
{
int coord = y - ActiveScreen->m_DrawOrg.y;
#ifndef WX_ZOOM
int coord = y - ActiveScreen->m_DrawOrg.y;
coord = ZoomValue( coord );
coord -= ActiveScreen->m_StartVisu.y;
#endif
return coord;
#else
return y;
#endif
}

145
common/zoom.cpp
View File

@ -30,9 +30,7 @@ void WinEDA_DrawFrame::Recadre_Trace( bool ToMouse )
*/
{
PutOnGrid( &(GetBaseScreen()->m_Curseur) );
AdjustScrollBars();
ReDrawPanel();
/* Move the mouse cursor to the on grid graphic cursor position */
@ -69,10 +67,7 @@ void WinEDA_DrawFrame::Zoom_Automatique( bool move_mouse_cursor )
/** Redraw the screen with the zoom level which shows all the page or the board
*/
{
int bestzoom;
bestzoom = BestZoom();
GetBaseScreen()->SetZoom( bestzoom );
GetBaseScreen()->SetZoom( BestZoom() );
Recadre_Trace( move_mouse_cursor );
}
@ -100,8 +95,7 @@ void WinEDA_DrawFrame::Window_Zoom( EDA_Rect& Rect )
if( bestzoom <= 0 )
bestzoom = 1;
GetBaseScreen()->SetZoom( bestzoom );
GetBaseScreen()->SetZoom( bestzoom * GetBaseScreen()->m_ZoomScalar );
GetBaseScreen()->m_Curseur = Rect.Centre();
Recadre_Trace( TRUE );
}
@ -112,13 +106,14 @@ void WinEDA_DrawFrame::OnZoom( wxCommandEvent& event )
{
if( DrawPanel == NULL )
{
wxLogDebug( wxT( "No DrawPanel object definedin " \
wxLogDebug( wxT( "No DrawPanel object defined in " \
"WinEDA_DrawFrame::OnZoom()." ) );
return;
}
bool zoom_at_cursor = false;
int i;
int id = event.GetId();
bool zoom_at_cursor = false;
BASE_SCREEN* screen = GetBaseScreen();
switch( id )
@ -164,69 +159,22 @@ void WinEDA_DrawFrame::OnZoom( wxCommandEvent& event )
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_ZOOM_LEVEL_1:
screen->SetZoom( 1 );
Recadre_Trace( true );
break;
case ID_POPUP_ZOOM_LEVEL_2:
screen->SetZoom( 2 );
Recadre_Trace( true );
break;
case ID_POPUP_ZOOM_LEVEL_4:
screen->SetZoom( 4 );
Recadre_Trace( true );
break;
case ID_POPUP_ZOOM_LEVEL_8:
screen->SetZoom( 8 );
Recadre_Trace( true );
break;
case ID_POPUP_ZOOM_LEVEL_16:
screen->SetZoom( 16 );
Recadre_Trace( true );
break;
case ID_POPUP_ZOOM_LEVEL_32:
screen->SetZoom( 32 );
Recadre_Trace( true );
break;
case ID_POPUP_ZOOM_LEVEL_64:
screen->SetZoom( 64 );
Recadre_Trace( true );
break;
case ID_POPUP_ZOOM_LEVEL_128:
screen->SetZoom( 128 );
Recadre_Trace( true );
break;
case ID_POPUP_ZOOM_LEVEL_256:
screen->SetZoom( 256 );
Recadre_Trace( true );
break;
case ID_POPUP_ZOOM_LEVEL_512:
screen->SetZoom( 512 );
Recadre_Trace( true );
break;
case ID_POPUP_ZOOM_LEVEL_1024:
screen->SetZoom( 1024 );
Recadre_Trace( true );
break;
default:
i = id - ID_POPUP_ZOOM_LEVEL_START;
case ID_POPUP_ZOOM_LEVEL_2048:
screen->SetZoom( 2048 );
if( i < 0 )
{
wxLogDebug( wxT( "WinEDA_DrawFram::OnZoom() invalid ID %d" ), id );
return;
}
if( !( (size_t) i < screen->m_ZoomList.GetCount()) )
{
wxLogDebug( _T( "Requested index %d is outside the bounds of " \
"the zoom list." ), i );
return;
}
screen->SetZoom( screen->m_ZoomList[i] );
Recadre_Trace( true );
break;
default:
wxLogDebug( wxT( "WinEDA_DrawFram::OnZoom() unhandled ID %d" ), id );
return;
}
Affiche_Status_Box();
@ -246,14 +194,14 @@ void WinEDA_DrawPanel::AddMenuZoom( wxMenu* MasterMenu )
* used in OnRightClick(wxMouseEvent& event)
*/
{
size_t i;
int zoom;
wxSize grid;
int zoom_value;
wxString msg;
int ii;
wxString line;
GRID_TYPE tmp;
size_t i;
int maxZoomIds;
int zoom;
wxSize grid;
wxString msg;
GRID_TYPE tmp;
wxMenu* gridMenu;
double gridValue;
ADD_MENUITEM( MasterMenu, ID_POPUP_ZOOM_CENTER, _( "Center" ),
zoom_center_xpm );
@ -269,23 +217,27 @@ void WinEDA_DrawPanel::AddMenuZoom( wxMenu* MasterMenu )
ADD_MENUITEM( MasterMenu, ID_ZOOM_REDRAW, _( "Redraw view" ),
zoom_redraw_xpm );
/* Create the basic zoom list: */
zoom = GetScreen()->GetZoom();
zoom_value = 1;
for( ii = 0; zoom_value <= m_Parent->m_ZoomMaxValue; zoom_value <<= 1, ii++ ) // Create zoom choice 1 .. zoom max
maxZoomIds = ID_POPUP_ZOOM_LEVEL_END - ID_POPUP_ZOOM_LEVEL_START;
maxZoomIds = ( (size_t) maxZoomIds < GetScreen()->m_ZoomList.GetCount() ) ?
maxZoomIds : GetScreen()->m_ZoomList.GetCount();
wxLogDebug( _T( "%d zoom IDs used." ), maxZoomIds );
/* Populate zoom submenu. */
for( i = 0; i < (size_t) maxZoomIds; i++ )
{
line.Printf( wxT( "%u" ), zoom_value );
zoom_choice->Append( ID_POPUP_ZOOM_LEVEL_1 + ii,
_( "Zoom: " ) + line, wxEmptyString, TRUE );
if( zoom == zoom_value )
zoom_choice->Check( ID_POPUP_ZOOM_LEVEL_1 + ii, TRUE );
msg.Printf( wxT( "%u" ), GetScreen()->m_ZoomList[i] );
zoom_choice->Append( ID_POPUP_ZOOM_LEVEL_START + i, _( "Zoom: " ) + msg,
wxEmptyString, wxITEM_CHECK );
if( zoom == GetScreen()->m_ZoomList[i] )
zoom_choice->Check( ID_POPUP_ZOOM_LEVEL_START + i, true );
}
/* Create grid submenu as required. */
if( !GetScreen()->m_GridList.IsEmpty() )
{
wxMenu* grid_choice = new wxMenu;
ADD_MENUITEM_WITH_SUBMENU( MasterMenu, grid_choice,
gridMenu = new wxMenu;
ADD_MENUITEM_WITH_SUBMENU( MasterMenu, gridMenu,
ID_POPUP_GRID_SELECT, _( "Grid Select" ),
grid_select_xpm );
@ -294,9 +246,8 @@ void WinEDA_DrawPanel::AddMenuZoom( wxMenu* MasterMenu )
for( i = 0; i < GetScreen()->m_GridList.GetCount(); i++ )
{
tmp = GetScreen()->m_GridList[i];
double grid_value = To_User_Unit( g_UnitMetric,
tmp.m_Size.x,
( (WinEDA_DrawFrame*)m_Parent )->m_InternalUnits );
gridValue = To_User_Unit( g_UnitMetric, tmp.m_Size.x,
( (WinEDA_DrawFrame*)m_Parent )->m_InternalUnits );
if( tmp.m_Id == ID_POPUP_GRID_USER )
{
msg = _( "User Grid" );
@ -304,14 +255,14 @@ void WinEDA_DrawPanel::AddMenuZoom( wxMenu* MasterMenu )
else
{
if ( g_UnitMetric == 0 ) // inches
line.Printf( wxT( "%g mils" ), grid_value*1000 );
msg.Printf( wxT( "%g mils" ), gridValue * 1000 );
else
line.Printf( wxT( "%g mm" ), grid_value );
msg = _( "Grid: " ) + line;
msg.Printf( wxT( "%g mm" ), gridValue );
msg = _( "Grid: " ) + msg;
}
grid_choice->Append( tmp.m_Id, msg, wxEmptyString, true );
gridMenu->Append( tmp.m_Id, msg, wxEmptyString, true );
if( grid == tmp.m_Size )
grid_choice->Check( tmp.m_Id, true );
gridMenu->Check( tmp.m_Id, true );
}
}

4
cvpcb/displayframe.cpp
View File

@ -179,7 +179,6 @@ void WinEDA_DisplayFrame::GeneralControle( wxDC* DC, wxPoint Mouse )
{
wxSize delta;
int flagcurseur = 0;
int zoom = GetScreen()->GetZoom();
wxPoint curpos, oldpos;
wxCommandEvent cmd( wxEVT_COMMAND_MENU_SELECTED );
cmd.SetEventObject( this );
@ -187,7 +186,8 @@ void WinEDA_DisplayFrame::GeneralControle( wxDC* DC, wxPoint Mouse )
curpos = DrawPanel->CursorRealPosition( Mouse );
oldpos = GetScreen()->m_Curseur;
delta = GetScreen()->GetGrid() / zoom;
delta = GetScreen()->GetGrid();
GetScreen()->Scale( delta );
if( delta.x <= 0 )
delta.x = 1;

2
eeschema/block.cpp
View File

@ -4,7 +4,7 @@
/****************************************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "program.h"
#include "libcmp.h"

12
eeschema/class_drawsheet.cpp
View File

@ -11,18 +11,8 @@
// Licence: License GNU
/////////////////////////////////////////////////////////////////////////////
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "program.h"

11
eeschema/class_hierarchical_PIN_sheet.cpp
View File

@ -11,17 +11,6 @@
// Licence:
/////////////////////////////////////////////////////////////////////////////
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
#include "fctsys.h"
#include "gr_basic.h"

2
eeschema/class_pin.cpp
View File

@ -3,7 +3,7 @@
/*****************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "program.h"
#include "libcmp.h"

14
eeschema/class_screen.cpp
View File

@ -1,6 +1,6 @@
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "program.h"
#include "libcmp.h"
@ -78,7 +78,13 @@ void SCH_ITEM::Place( WinEDA_SchematicFrame* frame, wxDC* DC )
/***********************************************************************/
/* Class SCH_SCREEN: classe de gestion d'un affichage pour schematique */
/***********************************************************************/
static int table_zoom[] = { 1, 2, 4, 8, 16, 32, 64, 128, 0 }; /* Valeurs standards du zoom */
/* Default EESchema zoom values. */
static int SchematicZoomList[] = { 10, 15, 20, 40, 80, 160, 320, 640, 1280 };
#define SCHEMATIC_ZOOM_LIST_CNT ( sizeof( SchematicZoomList ) / \
sizeof( int ) )
/* Default grid sizes for the schematic editor. */
static GRID_TYPE SchematicGridList[] = {
@ -101,7 +107,9 @@ SCH_SCREEN::SCH_SCREEN( KICAD_T type ) : BASE_SCREEN( type )
EEDrawList = NULL; /* Schematic items list */
m_Zoom = 32;
SetZoomList( table_zoom );
for( i = 0; i < SCHEMATIC_ZOOM_LIST_CNT; i++ )
m_ZoomList.Add( SchematicZoomList[i] );
for( i = 0; i < SCHEMATIC_GRID_LIST_CNT; i++ )
AddGrid( SchematicGridList[i] );

18
eeschema/controle.cpp
View File

@ -222,7 +222,6 @@ void WinEDA_SchematicFrame::GeneralControle( wxDC* DC, wxPoint MousePositionInPi
{
wxSize delta;
SCH_SCREEN* screen = GetScreen();
int zoom = screen->GetZoom();
wxPoint curpos, oldpos;
int hotkey = 0;
@ -231,7 +230,8 @@ void WinEDA_SchematicFrame::GeneralControle( wxDC* DC, wxPoint MousePositionInPi
curpos = screen->m_MousePosition;
oldpos = screen->m_Curseur;
delta = screen->GetGrid() / zoom;
delta = screen->GetGrid();
screen->Scale( delta );
if( delta.x <= 0 )
delta.x = 1;
@ -316,7 +316,6 @@ void WinEDA_LibeditFrame::GeneralControle( wxDC* DC, wxPoint MousePositionInPixe
{
wxSize delta;
SCH_SCREEN* screen = GetScreen();
int zoom = screen->GetZoom();
wxPoint curpos, oldpos;
int hotkey = 0;
@ -325,7 +324,8 @@ void WinEDA_LibeditFrame::GeneralControle( wxDC* DC, wxPoint MousePositionInPixe
curpos = screen->m_MousePosition;
oldpos = screen->m_Curseur;
delta = screen->GetGrid() / zoom;
delta = screen->GetGrid();
screen->Scale( delta );
if( delta.x <= 0 )
delta.x = 1;
@ -403,13 +403,12 @@ void WinEDA_LibeditFrame::GeneralControle( wxDC* DC, wxPoint MousePositionInPixe
SetToolbars();
}
/*************************************************************************************/
void WinEDA_ViewlibFrame::GeneralControle( wxDC* DC, wxPoint MousePositionInPixels )
/*************************************************************************************/
/*****************************************************************************/
void WinEDA_ViewlibFrame::GeneralControle( wxDC* DC,
wxPoint MousePositionInPixels )
{
wxSize delta;
SCH_SCREEN* screen = GetScreen();
int zoom = screen->GetZoom();
wxPoint curpos, oldpos;
int hotkey = 0;
@ -418,7 +417,8 @@ void WinEDA_ViewlibFrame::GeneralControle( wxDC* DC, wxPoint MousePositionInPixe
curpos = screen->m_MousePosition;
oldpos = screen->m_Curseur;
delta = screen->GetGrid() / zoom;
delta = screen->GetGrid();
screen->Scale( delta );
if( delta.x <= 0 )
delta.x = 1;

2
eeschema/dialog_SVG_print.cpp
View File

@ -7,7 +7,7 @@
/////////////////////////////////////////////////////////////////////////////
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "dialog_SVG_print_base.h"

1
eeschema/dialog_print_using_printer.cpp
View File

@ -5,6 +5,7 @@
// Set this to 1 if you want to test PostScript printing under MSW.
#define wxTEST_POSTSCRIPT_IN_MSW 1
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"

1
eeschema/edit_graphic_bodyitem_text.cpp
View File

@ -8,6 +8,7 @@
*/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "program.h"

1
eeschema/eeconfig.cpp
View File

@ -3,6 +3,7 @@
/*******************************************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "program.h"
#include "libcmp.h"

2
eeschema/eelibs_draw_components.cpp
View File

@ -167,7 +167,7 @@ void DrawLibEntry( WinEDA_DrawPanel* panel, wxDC* DC,
}
// Trace de l'ancre
int len = 3 * panel->GetZoom();
int len = panel->GetScreen()->Unscale( 3 );
GRLine( &panel->m_ClipBox, DC, aOffset.x, aOffset.y - len, aOffset.x, aOffset.y + len, 0, color );
GRLine( &panel->m_ClipBox, DC, aOffset.x - len, aOffset.y, aOffset.x + len, aOffset.y, 0, color );
}

29
eeschema/eeredraw.cpp
View File

@ -211,14 +211,13 @@ void RedrawOneStruct( WinEDA_DrawPanel* panel, wxDC* DC,
}
/*****************************************************************************************/
void EDA_DrawLineStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int DrawMode, int Color )
/*****************************************************************************************/
/****************************************************************************/
/* Draw wires, Bus, and dashed liges.. */
/****************************************************************************/
void EDA_DrawLineStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int DrawMode, int Color )
{
int color;
int zoom = panel->GetZoom();
int width = MAX( m_Width, g_DrawMinimunLineWidth );
if( Color >= 0 )
@ -227,15 +226,19 @@ void EDA_DrawLineStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint&
color = ReturnLayerColor( m_Layer );
GRSetDrawMode( DC, DrawMode );
if( (m_Layer == LAYER_BUS) && (zoom <= 16) )
// FIXME: Not compatable with new zoom.
if( (m_Layer == LAYER_BUS) && panel->GetScreen()->Scale( width ) <= 1 )
width *= 3;
if( m_Layer == LAYER_NOTES )
GRDashedLine( &panel->m_ClipBox, DC, m_Start.x + offset.x, m_Start.y + offset.y,
m_End.x + offset.x, m_End.y + offset.y, width, color );
GRDashedLine( &panel->m_ClipBox, DC, m_Start.x + offset.x,
m_Start.y + offset.y, m_End.x + offset.x,
m_End.y + offset.y, width, color );
else
GRLine( &panel->m_ClipBox, DC, m_Start.x + offset.x, m_Start.y + offset.y,
m_End.x + offset.x, m_End.y + offset.y, width, color );
GRLine( &panel->m_ClipBox, DC, m_Start.x + offset.x,
m_Start.y + offset.y, m_End.x + offset.x, m_End.y + offset.y,
width, color );
if( m_StartIsDangling )
DrawDanglingSymbol( panel, DC, m_Start + offset, color );
@ -310,7 +313,6 @@ void DrawBusEntryStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint&
{
int color;
int zoom = panel->GetZoom();
int width = MAX( m_Width, g_DrawMinimunLineWidth );
if( Color >= 0 )
@ -319,7 +321,7 @@ void DrawBusEntryStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint&
color = ReturnLayerColor( m_Layer );
GRSetDrawMode( DC, DrawMode );
if( (m_Layer == LAYER_BUS) && (zoom <= 16) )
if( m_Layer == LAYER_BUS )
width *= 3;
GRLine( &panel->m_ClipBox, DC, m_Pos.x + offset.x, m_Pos.y + offset.y,
@ -345,7 +347,6 @@ void DrawPolylineStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint&
int DrawMode, int Color )
{
int color;
int zoom = panel->GetZoom();
int width = MAX( m_Width, g_DrawMinimunLineWidth );
if( Color >= 0 )
@ -355,7 +356,7 @@ void DrawPolylineStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint&
GRSetDrawMode( DC, DrawMode );
if( (m_Layer == LAYER_BUS) && (zoom <= 16) )
if( m_Layer == LAYER_BUS )
{
width *= 3;
}

1
eeschema/erc.cpp
View File

@ -3,6 +3,7 @@
/**************************************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "program.h"

1
eeschema/getpart.cpp
View File

@ -3,6 +3,7 @@
/*************************************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"

12
eeschema/hierarch.cpp
View File

@ -326,12 +326,12 @@ static bool UpdateScreenFromSheet( WinEDA_SchematicFrame* frame )
// Reinit des parametres d'affichage du nouvel ecran
// assumes m_CurrentSheet has already been updated.
frame->MsgPanel->EraseMsgBox();
frame->DrawPanel->SetScrollbars( frame->DrawPanel->m_Scroll_unit,
frame->DrawPanel->m_Scroll_unit,
NewScreen->m_ScrollbarNumber.x,
NewScreen->m_ScrollbarNumber.y,
NewScreen->m_ScrollbarPos.x,
NewScreen->m_ScrollbarPos.y, TRUE );
frame->DrawPanel->SetScrollbars( NewScreen->m_ZoomScalar,
NewScreen->m_ZoomScalar,
NewScreen->m_ScrollbarNumber.x,
NewScreen->m_ScrollbarNumber.y,
NewScreen->m_ScrollbarPos.x,
NewScreen->m_ScrollbarPos.y, TRUE );
//update the References
frame->m_CurrentSheet->UpdateAllScreenReferences();

1086
eeschema/libedit.cpp
File diff suppressed because it is too large
View File

2
eeschema/libframe.cpp
View File

@ -281,7 +281,7 @@ int WinEDA_LibeditFrame::BestZoom()
GetScreen()->m_Curseur.y = 0;
}
return bestzoom;
return bestzoom * GetScreen()->m_ZoomScalar;
}

5
eeschema/schframe.cpp
View File

@ -280,7 +280,7 @@ void WinEDA_SchematicFrame::CreateScreens()
if( g_ScreenLib == NULL )
g_ScreenLib = new SCH_SCREEN();
g_ScreenLib->SetZoom( 4 );
g_ScreenLib->SetZoom( 4 * g_ScreenLib->m_ZoomScalar );
g_ScreenLib->m_UndoRedoCountMax = 10;
}
@ -450,11 +450,10 @@ int WinEDA_SchematicFrame::BestZoom()
jj = dy / size.y;
bestzoom = MAX( ii, jj ) + 1;
GetScreen()->SetZoom( ii );
GetScreen()->m_Curseur.x = dx / 2;
GetScreen()->m_Curseur.y = dy / 2;
return bestzoom;
return bestzoom * GetScreen()->m_ZoomScalar;
}
/*******************************************************************/

1
eeschema/symbdraw.cpp
View File

@ -6,6 +6,7 @@
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "program.h"

2
eeschema/viewlib_frame.cpp
View File

@ -223,7 +223,7 @@ int WinEDA_ViewlibFrame::BestZoom()
GetScreen()->m_Curseur = BoundaryBox.Centre();
return bestzoom;
return bestzoom * GetScreen()->m_ZoomScalar;
}

2
eeschema/viewlibs.cpp
View File

@ -3,7 +3,7 @@
/****************************/
#include "fctsys.h"
//#include "gr_basic.h"
#include "gr_basic.h"
#include "common.h"
#include "program.h"

5
gerbview/controle.cpp
View File

@ -62,8 +62,9 @@ void WinEDA_BasePcbFrame::GeneralControle( wxDC* DC, wxPoint Mouse )
curpos = DrawPanel->CursorRealPosition( Mouse );
oldpos = GetScreen()->m_Curseur;
delta.x = GetScreen()->GetGrid().x / GetScreen()->GetZoom();
delta.y = GetScreen()->GetGrid().y / GetScreen()->GetZoom();
delta = GetScreen()->GetGrid();
GetScreen()->Scale( delta );
if( delta.x == 0 )
delta.x = 1;
if( delta.y == 0 )

24
gerbview/gerberframe.cpp
View File

@ -7,6 +7,7 @@
#endif
#include "fctsys.h"
#include "wxstruct.h"
#include "common.h"
#include "gerbview.h"
@ -137,7 +138,6 @@ WinEDA_GerberFrame::WinEDA_GerberFrame( wxWindow* father,
m_Draw_Grid = TRUE; // TRUE pour avoir la axes dessinee
m_Draw_Sheet_Ref = FALSE; // TRUE pour avoir le cartouche dessin�
m_Ident = GERBER_FRAME;
m_ZoomMaxValue = 1024;
if( DrawPanel )
DrawPanel->m_Block_Enable = TRUE;
@ -305,27 +305,17 @@ void WinEDA_GerberFrame::SetToolbars()
int WinEDA_GerberFrame::BestZoom()
/*************************************/
{
int ii, jj;
int ii, jj, gridX, gridY;
int bestzoom;
wxSize size;
/* calcul du zoom montrant tout le dessim */
GetBoard()->ComputeBoundaryBox();
gridX = GetScreen()->GetGrid().GetWidth() / 2;
gridY = GetScreen()->GetGrid().GetHeight() / 2;
size = DrawPanel->GetClientSize();
ii = GetBoard()->m_BoundaryBox.GetWidth() / size.x;
jj = GetBoard()->m_BoundaryBox.GetHeight() / size.y;
ii = ( GetBoard()->m_BoundaryBox.GetWidth() + gridX ) / size.x;
jj = ( GetBoard()->m_BoundaryBox.GetHeight() + gridY ) / size.y;
bestzoom = MAX( ii, jj ) + 1;
/* determination du zoom existant le plus proche */
for( ii = 1; ii < 2048; ii <<= 1 )
{
if( ii >= bestzoom )
break;
}
bestzoom = ii;
GetScreen()->m_Curseur = GetBoard()->m_BoundaryBox.Centre();
return bestzoom;
return bestzoom * GetScreen()->m_ZoomScalar;
}

1
gerbview/tracepcb.cpp
View File

@ -9,6 +9,7 @@
*/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "gerbview.h"

94
gerbview/trpiste.cpp
View File

@ -3,6 +3,7 @@
/*****************************************************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "gerbview.h"
@ -65,8 +66,9 @@ void Trace_Segment( WinEDA_DrawPanel* panel, wxDC* DC, TRACK* track, int draw_mo
{
int l_piste;
int color;
int zoom;
int fillopt;
int radius;
int halfPenWidth;
static bool show_err;
if( track->m_Flags & DRAW_ERASED ) // draw in background color, used by classs TRACK in gerbview
@ -92,37 +94,34 @@ void Trace_Segment( WinEDA_DrawPanel* panel, wxDC* DC, TRACK* track, int draw_mo
GRSetDrawMode( DC, draw_mode );
zoom = panel->GetZoom();
fillopt = DisplayOpt.DisplayPcbTrackFill ? FILLED : SKETCH;
switch( track->m_Shape )
{
case S_CIRCLE:
radius = (int) hypot( (double) (track->m_End.x - track->m_Start.x),
(double) (track->m_End.y - track->m_Start.y) );
halfPenWidth = track->m_Width >> 1;
if( panel->GetScreen()->Scale( halfPenWidth ) < L_MIN_DESSIN )
{
int radius = (int) hypot( (double) (track->m_End.x - track->m_Start.x),
(double) (track->m_End.y - track->m_Start.y) );
int halfPenWidth = track->m_Width >> 1;
if( (halfPenWidth / zoom) < L_MIN_DESSIN )
{
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
radius, 0, color );
}
if( fillopt == SKETCH )
{
// draw the border of the pen's path using two circles, each as narrow as possible
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
radius - halfPenWidth, 0, color );
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
radius + halfPenWidth, 0, color );
}
else
{
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
radius, track->m_Width, color );
}
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x,
track->m_Start.y, radius, 0, color );
}
if( fillopt == SKETCH )
{
// draw the border of the pen's path using two circles, each as narrow as possible
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
radius - halfPenWidth, 0, color );
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
radius + halfPenWidth, 0, color );
}
else
{
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
radius, track->m_Width, color );
}
break;
@ -143,25 +142,23 @@ void Trace_Segment( WinEDA_DrawPanel* panel, wxDC* DC, TRACK* track, int draw_mo
break;
case S_SPOT_CIRCLE:
radius = track->m_Width >> 1;
fillopt = DisplayOpt.DisplayPadFill ? FILLED : SKETCH;
if( panel->GetScreen()->Scale( radius ) < L_MIN_DESSIN )
{
int radius = track->m_Width >> 1;
fillopt = DisplayOpt.DisplayPadFill ? FILLED : SKETCH;
if( (radius / zoom) < L_MIN_DESSIN )
{
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
radius, 0, color );
}
else if( fillopt == SKETCH )
{
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
radius, 0, color );
}
else
{
GRFilledCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
radius, 0, color, color );
}
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x,
track->m_Start.y, radius, 0, color );
}
else if( fillopt == SKETCH )
{
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x,
track->m_Start.y, radius, 0, color );
}
else
{
GRFilledCircle( &panel->m_ClipBox, DC, track->m_Start.x,
track->m_Start.y, radius, 0, color, color );
}
break;
@ -171,7 +168,7 @@ void Trace_Segment( WinEDA_DrawPanel* panel, wxDC* DC, TRACK* track, int draw_mo
l_piste = track->m_Width >> 1;
fillopt = DisplayOpt.DisplayPadFill ? FILLED : SKETCH;
if( (l_piste / zoom) < L_MIN_DESSIN )
if( panel->GetScreen()->Scale( l_piste ) < L_MIN_DESSIN )
{
GRLine( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
track->m_End.x, track->m_End.y, 0, color );
@ -202,7 +199,7 @@ void Trace_Segment( WinEDA_DrawPanel* panel, wxDC* DC, TRACK* track, int draw_mo
case S_SEGMENT:
l_piste = track->m_Width >> 1;
if( (l_piste / zoom) < L_MIN_DESSIN )
if( panel->GetScreen()->Scale( l_piste ) < L_MIN_DESSIN )
{
GRLine( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
track->m_End.x, track->m_End.y, 0, color );
@ -212,13 +209,12 @@ void Trace_Segment( WinEDA_DrawPanel* panel, wxDC* DC, TRACK* track, int draw_mo
if( fillopt == SKETCH )
{
GRCSegm( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
track->m_End.x, track->m_End.y,
track->m_Width, color );
track->m_End.x, track->m_End.y, track->m_Width, color );
}
else
{
GRFillCSegm( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
track->m_End.x, track->m_End.y,
GRFillCSegm( &panel->m_ClipBox, DC, track->m_Start.x,
track->m_Start.y, track->m_End.x, track->m_End.y,
track->m_Width, color );
}
break;

8
include/appl_wxstruct.h
View File

@ -17,6 +17,7 @@
/* Use wxFileHistory for most recently used file handling. */
#include <wx/docview.h>
class PARAM_CFG_BASE;
/**********************************************/
/* Class representing the entire Application */
@ -70,6 +71,7 @@ public:
*/
void AddMenuLanguageList( wxMenu* MasterMenu );
void SetLanguageIdentifier( int menu_id );
void SetLanguagePath( void );
void InitOnLineHelp();
// Sauvegarde de configurations et options:
@ -85,6 +87,12 @@ public:
void ReadPdfBrowserInfos();
void WritePdfBrowserInfos();
wxString FindFileInSearchPaths( const wxString& filename,
const wxArrayString* subdirs = NULL );
wxString GetHelpFile( void );
wxString GetLibraryFile( const wxString& filename );
};
/*

2
include/base_struct.h
View File

@ -93,7 +93,7 @@ class EDA_BaseStruct;
class WinEDA_DrawFrame;
class BOARD;
class EDA_Rect;
class WinEDA_DrawPanel;
/**
* Class INSPECTOR

59
include/drawpanel_wxstruct.h
View File

@ -18,6 +18,8 @@
#include "colors.h"
class SCH_ITEM;
class BASE_SCREEN;
class Ki_PageDescr;
/* Simple class for handling grid arrays. */
class GRID_TYPE
@ -43,7 +45,6 @@ public:
WinEDA_DrawFrame* m_Parent;
EDA_Rect m_ClipBox; // the clipbox used in screen redraw (usually gives the visible area in internal units)
wxPoint m_CursorStartPos; // utile dans controles du mouvement curseur
int m_Scroll_unit; // Valeur de l'unite de scroll en pixels pour les barres de scroll
int m_ScrollButt_unit; // Valeur de l'unite de scroll en pixels pour les boutons de scroll
bool m_AbortRequest; // Flag d'arret de commandes longues
@ -265,20 +266,21 @@ public:
private:
/* indicateurs divers */
char m_FlagRefreshReq; /* indique que l'ecran doit redessine */
char m_FlagModified; // indique modif du PCB,utilise pour eviter une sortie sans sauvegarde
char m_FlagSave; // indique sauvegarde auto faite
EDA_BaseStruct* m_CurrentItem; ///< Currently selected object
char m_FlagRefreshReq; /* indique que l'ecran doit redessine */
char m_FlagModified; // indique modif du PCB,utilise pour eviter une sortie sans sauvegarde
char m_FlagSave; // indique sauvegarde auto faite
EDA_BaseStruct* m_CurrentItem; ///< Currently selected object
/* Valeurs du pas de grille et du zoom */
public:
wxSize m_Grid; /* Current grid. */
GridArray m_GridList;
bool m_UserGridIsON;
wxSize m_Grid; /* Current grid. */
GridArray m_GridList;
bool m_UserGridIsON;
int m_Diviseur_Grille;
int* m_ZoomList; /* Liste des coefficients standard de zoom */
int m_Zoom; /* coeff de ZOOM */
int m_Diviseur_Grille;
wxArrayInt m_ZoomList; /* Array of standard zoom coefficients. */
int m_Zoom; /* Current zoom coefficient. */
int m_ZoomScalar; /* Allow zooming to non-integer increments. */
public:
BASE_SCREEN( KICAD_T aType = SCREEN_STRUCT_TYPE );
@ -328,34 +330,41 @@ public:
* Function GetZoom
* returns the current zoom factor
*/
int GetZoom() const;
int GetZoom() const;
/**
* Function SetZoom
* adjusts the current zoom factor
*/
void SetZoom( int coeff );
void SetZoom( int coeff );
/**
* Function SetZoomList
* sets the list of zoom factors.
* @param aZoomList An array of zoom factors in ascending order, zero terminated
*/
void SetZoomList( const int* zoomlist );
void SetZoomList( const wxArrayInt& zoomlist );
void SetNextZoom(); /* ajuste le prochain coeff de zoom */
void SetPreviousZoom(); /* ajuste le precedent coeff de zoom */
void SetFirstZoom(); /* ajuste le coeff de zoom a 1*/
void SetLastZoom(); /* ajuste le coeff de zoom au max */
int Scale( int coord );
void Scale( wxPoint& pt );
void Scale( wxSize& sz );
int Unscale( int coord );
void Unscale( wxPoint& pt );
void Unscale( wxSize& sz );
void SetNextZoom(); /* ajuste le prochain coeff de zoom */
void SetPreviousZoom(); /* ajuste le precedent coeff de zoom */
void SetFirstZoom(); /* ajuste le coeff de zoom a 1*/
void SetLastZoom(); /* ajuste le coeff de zoom au max */
//----<grid stuff>----------------------------------------------------------
wxSize GetGrid(); /* retourne la grille */
void SetGrid( const wxSize& size );
void SetGrid( int );
void SetGridList( GridArray& sizelist );
void AddGrid( const GRID_TYPE& grid );
void AddGrid( const wxSize& size, int id );
void AddGrid( const wxRealPoint& size, int units, int id );
wxSize GetGrid(); /* retourne la grille */
void SetGrid( const wxSize& size );
void SetGrid( int );
void SetGridList( GridArray& sizelist );
void AddGrid( const GRID_TYPE& grid );
void AddGrid( const wxSize& size, int id );
void AddGrid( const wxRealPoint& size, int units, int id );
/**

1
include/fctsys.h
View File

@ -42,7 +42,6 @@
#define EESCHEMA_INTERNAL_UNIT 1000 // EESCHEMA internal unit = 1/1000 inch
#include "wxstruct.h"
#include "gr_basic.h"
// Old wxWidget compatibility (prior to wxWidget 2.7):
#if !wxCHECK_VERSION( 2, 7, 0 )

23
include/id.h
View File

@ -212,20 +212,15 @@ enum main_id {
ID_POPUP_ZOOM_OUT,
ID_POPUP_ZOOM_SELECT,
ID_POPUP_ZOOM_CENTER,
ID_POPUP_ZOOM_LEVEL_1,
ID_POPUP_ZOOM_LEVEL_2,
ID_POPUP_ZOOM_LEVEL_4,
ID_POPUP_ZOOM_LEVEL_8,
ID_POPUP_ZOOM_LEVEL_16,
ID_POPUP_ZOOM_LEVEL_32,
ID_POPUP_ZOOM_LEVEL_64,
ID_POPUP_ZOOM_LEVEL_128,
ID_POPUP_ZOOM_LEVEL_256,
ID_POPUP_ZOOM_LEVEL_512,
ID_POPUP_ZOOM_LEVEL_1024,
ID_POPUP_ZOOM_LEVEL_2048,
ID_POPUP_ZOOM_UNUSED0,
ID_POPUP_ZOOM_UNUSED1,
/* Reserve IDs for popup menu zoom levels. If you need more than 15
* levels of zoom, change ID_POPUP_ZOOM_LEVEL_END. Note that more
* than 15 entries in a context submenu may get too large to display
* cleanly. Add any additional popup zoom IDs above here or the
* zoom event handler will not work properly.
*/
ID_POPUP_ZOOM_LEVEL_START,
ID_POPUP_ZOOM_LEVEL_END = ID_POPUP_ZOOM_LEVEL_START + 15,
ID_POPUP_ZOOM_END_RANGE, // last zoom id
ID_POPUP_GRID_PLUS,

25
include/wxstruct.h
View File

@ -11,6 +11,8 @@
#define eda_global extern
#endif
#include <vector>
#include <wx/socket.h>
#include "wx/log.h"
#include "wx/config.h"
@ -18,7 +20,10 @@
#include <wx/laywin.h>
#include <wx/snglinst.h>
#include <vector>
#include "base_struct.h"
#include "appl_wxstruct.h"
#include "drawpanel_wxstruct.h"
#ifndef SAFE_DELETE
#define SAFE_DELETE(p) delete (p); (p) = NULL; //C++ guarantees that operator delete checks its argument for null-ness
@ -32,9 +37,10 @@
// Option for dialog boxes
// #define DIALOG_STYLE wxDEFAULT_DIALOG_STYLE|wxFRAME_FLOAT_ON_PARENT|wxSTAY_ON_TOP
#define DIALOG_STYLE wxDEFAULT_DIALOG_STYLE | wxFRAME_FLOAT_ON_PARENT | MAYBE_RESIZE_BORDER
#define DIALOG_STYLE wxDEFAULT_DIALOG_STYLE | wxFRAME_FLOAT_ON_PARENT | \
MAYBE_RESIZE_BORDER
#define KICAD_DEFAULT_DRAWFRAME_STYLE wxDEFAULT_FRAME_STYLE|wxWANTS_CHARS
#define KICAD_DEFAULT_DRAWFRAME_STYLE wxDEFAULT_FRAME_STYLE | wxWANTS_CHARS
class wxMyDialogModalData;
@ -42,8 +48,6 @@ class wxMyDialogModalData;
class WinEDA_DrawPanel;
class WinEDA_DrawFrame;
#include "base_struct.h"
class WinEDA_App;
class WinEDA_MsgPanel;
class COMMAND;
@ -108,11 +112,6 @@ enum id_toolbar {
#define MSG_PANEL_DEFAULT_HEIGHT ( 28 ) // height of the infos display window
/**********************************************/
/* Class representing the entire Application */
/**********************************************/
#include "appl_wxstruct.h"
/******************************************************************/
/* Basic frame for kicad, eeschema, pcbnew and gerbview. */
@ -183,7 +182,6 @@ public:
WinEDAChoiceBox* m_SelGridBox; // Dialog box to choose the grid size
WinEDAChoiceBox* m_SelZoomBox; // Dialog box to choose the Zoom value
int m_ZoomMaxValue; // Max zoom value: Draw min scale is 1/m_ZoomMaxValue
int m_CurrentCursorShape; // shape for cursor (0 = default cursor)
int m_ID_current_state; // Id of active button on the vertical toolbar
@ -279,7 +277,7 @@ public:
void ReDrawPanel();
void TraceWorkSheet( wxDC* DC, BASE_SCREEN* screen, int line_width );
void PlotWorkSheet( int format_plot, BASE_SCREEN* screen );
/** Function GetXYSheetReferences
* Return the X,Y sheet references where the point position is located
* @param aScreen = screen to use
@ -322,9 +320,6 @@ public:
/* classe representant un ecran graphique de dessin */
/****************************************************/
#include "drawpanel_wxstruct.h"
/*********************************************************
class WinEDA_MsgPanel : this is a panel to display various infos
and messages on items in eeschema an pcbnew

5
kicad/kicad.cpp
View File

@ -406,9 +406,8 @@ bool WinEDA_App::OnInit()
/* Splash screen logo */
#ifdef USE_SPLASH_IMAGE
wxString logoname( wxString( m_BinDir ) + _T( "logokicad.png" ) );
wxBitmap splash_screen;
if( splash_screen.LoadFile( logoname, wxBITMAP_TYPE_PNG ) )
wxBitmap bmp;
if( bmp.LoadFile( m_BinDir + _T( "logokicad.png" ), wxBITMAP_TYPE_PNG ) )
{
wxSplashScreen* splash = new wxSplashScreen( splash_screen,
wxSPLASH_CENTRE_ON_SCREEN | wxSPLASH_TIMEOUT,

6
pcbnew/basepcbframe.cpp
View File

@ -7,6 +7,7 @@
#endif
#include "fctsys.h"
#include "wxstruct.h"
#include "common.h"
#include "pcbnew.h"
@ -89,7 +90,7 @@ int WinEDA_BasePcbFrame::BestZoom( void )
wxSize size;
if( m_Pcb == NULL )
return 32;
return 32 * GetScreen()->m_ZoomScalar;
m_Pcb->ComputeBoundaryBox();
@ -100,10 +101,9 @@ int WinEDA_BasePcbFrame::BestZoom( void )
ii = ( dx + (size.x / 2) ) / size.x;
jj = ( dy + (size.y / 2) ) / size.y;
bestzoom = MAX( ii, jj ) + 1;
GetScreen()->m_Curseur = m_Pcb->m_BoundaryBox.Centre();
return bestzoom;
return bestzoom * GetScreen()->m_ZoomScalar;
}

1
pcbnew/block_module_editor.cpp
View File

@ -4,6 +4,7 @@
/****************************************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "pcbnew.h"

5
pcbnew/class_cotation.cpp
View File

@ -379,7 +379,6 @@ void COTATION::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
*/
{
int ox, oy, typeaff, width, gcolor;
int zoom = panel->GetScreen()->GetZoom();
ox = offset.x;
oy = offset.y;
@ -392,9 +391,9 @@ void COTATION::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
GRSetDrawMode( DC, mode_color );
typeaff = DisplayOpt.DisplayDrawItems;
width = m_Width;
if( width / zoom < 2 )
if( panel->GetScreen()->Scale( width ) < 2 )
typeaff = FILAIRE;
switch( typeaff )

89
pcbnew/class_drawsegment.cpp
View File

@ -132,19 +132,19 @@ wxPoint DRAWSEGMENT::GetStart() const
wxPoint DRAWSEGMENT::GetEnd() const
{
wxPoint center; // center point of the arc
wxPoint start; // start of arc
switch( m_Shape )
{
case S_ARC:
{
// rotate the starting point of the arc, given by m_End, through the angle m_Angle
// to get the ending point of the arc.
wxPoint center = m_Start; // center point of the arc
wxPoint start = m_End; // start of arc
// rotate the starting point of the arc, given by m_End, through the
// angle m_Angle to get the ending point of the arc.
center = m_Start; // center point of the arc
start = m_End; // start of arc
RotatePoint( &start.x, &start.y, center.x, center.y, -m_Angle );
RotatePoint( &start.x, &start.y, center.x, center.y, -m_Angle );
return start; // after rotation, the end of the arc.
}
return start; // after rotation, the end of the arc.
break;
case S_SEGMENT:
@ -156,23 +156,17 @@ wxPoint DRAWSEGMENT::GetEnd() const
void DRAWSEGMENT::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
int draw_mode, const wxPoint& notUsed )
int draw_mode, const wxPoint& notUsed )
{
int ux0, uy0, dx, dy;
int l_piste;
int color, mode;
int zoom;
int rayon;
color = g_DesignSettings.m_LayerColor[GetLayer()];
if( color & ITEM_NOT_SHOW )
return;
if( panel )
zoom = panel->GetZoom();
else
zoom = ActiveScreen->GetZoom();
GRSetDrawMode( DC, draw_mode );
l_piste = m_Width >> 1; /* l_piste = demi largeur piste */
@ -187,7 +181,7 @@ void DRAWSEGMENT::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
mode = DisplayOpt.DisplayDrawItems;
if( m_Flags & FORCE_SKETCH )
mode = SKETCH;
if( l_piste < (L_MIN_DESSIN * zoom) )
if( l_piste < panel->GetScreen()->Unscale( L_MIN_DESSIN ) )
mode = FILAIRE;
switch( m_Shape )
@ -210,39 +204,38 @@ void DRAWSEGMENT::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
break;
case S_ARC:
{
int StAngle, EndAngle;
rayon = (int) hypot( (double) (dx - ux0), (double) (dy - uy0) );
StAngle = (int) ArcTangente( dy - uy0, dx - ux0 );
EndAngle = StAngle + m_Angle;
int StAngle, EndAngle;
rayon = (int) hypot( (double) (dx - ux0), (double) (dy - uy0) );
StAngle = (int) ArcTangente( dy - uy0, dx - ux0 );
EndAngle = StAngle + m_Angle;
if ( ! panel->m_PrintIsMirrored)
{
if( StAngle > EndAngle )
EXCHG( StAngle, EndAngle );
}
else //Mirrored mode: arc orientation is reversed
{
if( StAngle < EndAngle )
EXCHG( StAngle, EndAngle );
}
if ( ! panel->m_PrintIsMirrored)
{
if( StAngle > EndAngle )
EXCHG( StAngle, EndAngle );
}
else //Mirrored mode: arc orientation is reversed
{
if( StAngle < EndAngle )
EXCHG( StAngle, EndAngle );
}
if( mode == FILAIRE )
GRArc( &panel->m_ClipBox, DC, ux0, uy0, StAngle, EndAngle, rayon, color );
if( mode == FILAIRE )
GRArc( &panel->m_ClipBox, DC, ux0, uy0, StAngle, EndAngle,
rayon, color );
else if( mode == SKETCH )
{
GRArc( &panel->m_ClipBox, DC, ux0, uy0, StAngle, EndAngle,
rayon - l_piste, color );
GRArc( &panel->m_ClipBox, DC, ux0, uy0, StAngle, EndAngle,
rayon + l_piste, color );
}
else
{
GRArc( &panel->m_ClipBox, DC, ux0, uy0, StAngle, EndAngle,
rayon, m_Width, color );
}
else if( mode == SKETCH )
{
GRArc( &panel->m_ClipBox, DC, ux0, uy0, StAngle, EndAngle,
rayon - l_piste, color );
GRArc( &panel->m_ClipBox, DC, ux0, uy0, StAngle, EndAngle,
rayon + l_piste, color );
}
else
{
GRArc( &panel->m_ClipBox, DC, ux0, uy0, StAngle, EndAngle,
rayon, m_Width, color );
}
break;
@ -339,7 +332,7 @@ bool DRAWSEGMENT::HitTest( const wxPoint& ref_pos )
rayon = (int) hypot( (double) (dx), (double) (dy) );
dist = (int) hypot( (double) (spot_cX), (double) (spot_cY) );
if( abs( rayon - dist ) <= (m_Width / 2) )
if( abs( rayon - dist ) <= ( m_Width / 2 ) )
{
if( m_Shape == S_CIRCLE )
return true;
@ -355,7 +348,7 @@ bool DRAWSEGMENT::HitTest( const wxPoint& ref_pos )
endAngle -= 3600;
}
if( mouseAngle >= stAngle && mouseAngle <= endAngle )
if( mouseAngle >= stAngle && mouseAngle <= endAngle )
return true;
}
}

51
pcbnew/class_edge_mod.cpp
View File

@ -98,7 +98,6 @@ void EDGE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
{
int ux0, uy0, dx, dy, rayon, StAngle, EndAngle;
int color, type_trace;
int zoom;
int typeaff;
PCB_SCREEN* screen;
WinEDA_BasePcbFrame* frame;
@ -115,8 +114,6 @@ void EDGE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
screen = frame->GetScreen();
zoom = screen->GetZoom();
type_trace = m_Shape;
ux0 = m_Start.x - offset.x;
@ -133,7 +130,7 @@ void EDGE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
if( !typeaff )
typeaff = SKETCH;
}
if( (m_Width / zoom) < L_MIN_DESSIN )
if( panel->GetScreen()->Scale( m_Width ) < L_MIN_DESSIN )
typeaff = FILAIRE;
switch( type_trace )
@ -158,12 +155,15 @@ void EDGE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
{
if( typeaff == FILLED )
{
GRCircle( &panel->m_ClipBox, DC, ux0, uy0, rayon, m_Width, color );
GRCircle( &panel->m_ClipBox, DC, ux0, uy0, rayon,
m_Width, color );
}
else // SKETCH Mode
{
GRCircle( &panel->m_ClipBox, DC, ux0, uy0, rayon + (m_Width / 2), color );
GRCircle( &panel->m_ClipBox, DC, ux0, uy0, rayon - (m_Width / 2), color );
GRCircle( &panel->m_ClipBox, DC, ux0, uy0,
rayon + (m_Width / 2), color );
GRCircle( &panel->m_ClipBox, DC, ux0, uy0,
rayon - (m_Width / 2), color );
}
}
break;
@ -176,7 +176,8 @@ void EDGE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
EXCHG( StAngle, EndAngle );
if( typeaff == FILAIRE )
{
GRArc( &panel->m_ClipBox, DC, ux0, uy0, StAngle, EndAngle, rayon, color );
GRArc( &panel->m_ClipBox, DC, ux0, uy0, StAngle, EndAngle,
rayon, color );
}
else if( typeaff == FILLED )
{
@ -193,30 +194,28 @@ void EDGE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
break;
case S_POLYGON:
{
// We must compute true coordinates from m_PolyPoints
// which are relative to module position, orientation 0
// We must compute true coordinates from m_PolyPoints
// which are relative to module position, orientation 0
std::vector<wxPoint> points = m_PolyPoints;
for( unsigned ii = 0; ii < points.size(); ii++ )
{
wxPoint& pt = points[ii];
std::vector<wxPoint> points = m_PolyPoints;
if( Module )
{
RotatePoint( &pt.x, &pt.y, Module->m_Orient );
pt.x += Module->m_Pos.x;
pt.y += Module->m_Pos.y;
}
for( unsigned ii = 0; ii < points.size(); ii++ )
{
wxPoint& pt = points[ii];
pt.x += m_Start0.x - offset.x;
pt.y += m_Start0.y - offset.y;
if( Module )
{
RotatePoint( &pt.x, &pt.y, Module->m_Orient );
pt.x += Module->m_Pos.x;
pt.y += Module->m_Pos.y;
}
GRPoly( &panel->m_ClipBox, DC, points.size(), &points[0],
TRUE, m_Width, color, color );
pt.x += m_Start0.x - offset.x;
pt.y += m_Start0.y - offset.y;
}
GRPoly( &panel->m_ClipBox, DC, points.size(), &points[0],
TRUE, m_Width, color, color );
break;
}
}

3
pcbnew/class_marker.cpp
View File

@ -161,8 +161,7 @@ bool MARKER::HitTest( const wxPoint& refPos )
wxSize TrueSize = m_Size;
if ( ActiveScreen )
{
TrueSize.x *= ActiveScreen->GetZoom();
TrueSize.y *= ActiveScreen->GetZoom();
ActiveScreen->Unscale( TrueSize );
}
wxPoint pos = GetPosition();

5
pcbnew/class_mire.cpp
View File

@ -106,7 +106,6 @@ void MIREPCB::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
int rayon, ox, oy, gcolor, width;
int dx1, dx2, dy1, dy2;
int typeaff;
int zoom;
ox = m_Pos.x + offset.x;
oy = m_Pos.y + offset.y;
@ -115,12 +114,10 @@ void MIREPCB::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
if( (gcolor & ITEM_NOT_SHOW) != 0 )
return;
zoom = panel->GetZoom();
GRSetDrawMode( DC, mode_color );
typeaff = DisplayOpt.DisplayDrawItems;
width = m_Width;
if( width / zoom < 2 )
if( panel->GetScreen()->Scale( width ) < 2 )
typeaff = FILAIRE;
/* Trace du cercle: */

3
pcbnew/class_module.cpp
View File

@ -32,8 +32,7 @@ void MODULE::DrawAncre( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset
* (doit etre fait apres les pads,
* car le trace du trou efface tout donc peut etre l'ancre */
{
int zoom = panel->GetZoom();
int anchor_size = dim_ancre * zoom;
int anchor_size = panel->GetScreen()->Unscale( dim_ancre );
GRSetDrawMode( DC, draw_mode );

8
pcbnew/class_pad_draw_functions.cpp
View File

@ -30,7 +30,6 @@ void D_PAD::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoin
xc, yc;
int angle;
wxPoint coord[4];
int zoom;
int fillpad = 0;
wxPoint shape_pos;
@ -39,7 +38,6 @@ void D_PAD::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoin
wxASSERT( panel );
zoom = panel->GetZoom();
WinEDA_BasePcbFrame* frame = (WinEDA_BasePcbFrame*) panel->m_Parent;
PCB_SCREEN* screen = frame->GetScreen();
@ -341,7 +339,7 @@ void D_PAD::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoin
switch( m_DrillShape )
{
case PAD_CIRCLE:
if( (hole / zoom) > 1 ) /* draw hole if its size is enought */
if( screen->Scale( hole ) > 1 ) /* draw hole if its size is enought */
GRFilledCircle( &panel->m_ClipBox, DC, cx0, cy0, hole, 0, color, color );
break;
@ -435,7 +433,7 @@ void D_PAD::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoin
int tsize = min( AreaSize.y, AreaSize.x / numpad_len );
#define CHAR_SIZE_MIN 5
if( (tsize / zoom) >= CHAR_SIZE_MIN ) // Not drawable when size too small.
if( screen->Scale( tsize ) >= CHAR_SIZE_MIN ) // Not drawable when size too small.
{
tsize = (int) (tsize * 0.8); // reserve room for marges and segments thickness
@ -450,7 +448,7 @@ void D_PAD::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoin
shortname_len = MAX( shortname_len, MIN_CHAR_COUNT);
tsize = min( AreaSize.y, AreaSize.x / shortname_len );
if( (tsize / zoom) >= CHAR_SIZE_MIN ) // Not drawable in size too small.
if( screen->Scale( tsize ) >= CHAR_SIZE_MIN ) // Not drawable in size too small.
{
tpos = tpos0;
tpos.y += AreaSize.y / 2;

17
pcbnew/class_text_mod.cpp
View File

@ -353,7 +353,6 @@ void TEXTE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const
* @param draw_mode = GR_OR, GR_XOR..
*/
{
int zoom;
int width, color, orient;
wxSize size;
wxPoint pos; // Centre du texte
@ -367,7 +366,6 @@ void TEXTE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const
screen = (PCB_SCREEN*) panel->GetScreen();
frame = (WinEDA_BasePcbFrame*) panel->m_Parent;
zoom = screen->GetZoom();
pos.x = m_Pos.x - offset.x;
pos.y = m_Pos.y - offset.y;
@ -376,7 +374,8 @@ void TEXTE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const
orient = GetDrawRotation();
width = m_Width;
if( (frame->m_DisplayModText == FILAIRE) || ( (width / zoom) < L_MIN_DESSIN ) )
if( (frame->m_DisplayModText == FILAIRE)
|| ( screen->Scale( width ) < L_MIN_DESSIN ) )
width = 0;
else if( frame->m_DisplayModText == SKETCH )
width = -width;
@ -386,13 +385,13 @@ void TEXTE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const
/* trace du centre du texte */
if( (g_AnchorColor & ITEM_NOT_SHOW) == 0 )
{
int anchor_size = 2 * zoom;
int anchor_size = screen->Unscale( 2 );
GRLine( &panel->m_ClipBox, DC,
pos.x - anchor_size, pos.y,
pos.x + anchor_size, pos.y, 0, g_AnchorColor );
pos.x - anchor_size, pos.y,
pos.x + anchor_size, pos.y, 0, g_AnchorColor );
GRLine( &panel->m_ClipBox, DC,
pos.x, pos.y - anchor_size,
pos.x, pos.y + anchor_size, 0, g_AnchorColor );
pos.x, pos.y - anchor_size,
pos.x, pos.y + anchor_size, 0, g_AnchorColor );
}
color = g_DesignSettings.m_LayerColor[Module->GetLayer()];
@ -418,7 +417,7 @@ void TEXTE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const
/* Trace du texte */
DrawGraphicText( panel, DC, pos, (enum EDA_Colors) color, m_Text,
orient, size, m_HJustify, m_VJustify, width, m_Italic );
orient, size, m_HJustify, m_VJustify, width, m_Italic );
}

32
pcbnew/class_track.cpp
View File

@ -535,7 +535,6 @@ void TRACK::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoin
{
int l_piste;
int color;
int zoom;
int rayon;
int curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
@ -545,7 +544,8 @@ void TRACK::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoin
if( m_Flags & DRAW_ERASED ) // draw in background color, used by classs TRACK in gerbview
{
color = g_DrawBgColor;
D( printf( "DRAW_ERASED in Track::Draw, g_DrawBgColor=%04X\n", g_DrawBgColor ); )
D( printf( "DRAW_ERASED in Track::Draw, g_DrawBgColor=%04X\n",
g_DrawBgColor ); )
}
else
{
@ -579,7 +579,6 @@ void TRACK::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoin
GRSetDrawMode( DC, draw_mode );
zoom = panel->GetZoom();
l_piste = m_Width >> 1;
@ -587,13 +586,13 @@ void TRACK::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoin
{
rayon = (int) hypot( (double) ( m_End.x - m_Start.x ),
(double) ( m_End.y - m_Start.y ) );
if( (l_piste / zoom) < L_MIN_DESSIN )
if( panel->GetScreen()->Scale( l_piste ) < L_MIN_DESSIN )
{
GRCircle( &panel->m_ClipBox, DC, m_Start.x, m_Start.y, rayon, color );
}
else
{
if( l_piste <= zoom ) /* Sketch mode if l_piste/zoom <= 1 */
if( panel->GetScreen()->Scale( l_piste ) <= 1 ) /* Sketch mode if l_piste/zoom <= 1 */
{
GRCircle( &panel->m_ClipBox, DC, m_Start.x, m_Start.y, rayon, color );
}
@ -611,7 +610,7 @@ void TRACK::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoin
return;
}
if( (l_piste / zoom) < L_MIN_DESSIN )
if( panel->GetScreen()->Scale( l_piste ) < L_MIN_DESSIN )
{
GRLine( &panel->m_ClipBox, DC, m_Start.x, m_Start.y,
m_End.x, m_End.y, 0, color );
@ -658,7 +657,7 @@ void TRACK::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoin
if( len < THRESHOLD * m_Width )
return;
if( ( m_Width / zoom) < 6 ) // no room to display a text inside track
if( panel->GetScreen()->Scale( m_Width ) < 6 ) // no room to display a text inside track
return;
if( GetNet() == 0 )
@ -680,7 +679,7 @@ void TRACK::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoin
int angle = 0;
if ( (m_End.x - m_Start.x) == 0 ) // Vertical segment
angle = 900; // angle is in 0.1 degree
if( ( tsize / zoom) >= 6 )
if( panel->GetScreen()->Scale( tsize ) >= 6 )
{
tsize = (tsize * 8) / 10; // small reduction to give a better look
DrawGraphicText( panel, DC, tpos,
@ -696,7 +695,6 @@ void SEGVIA::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoi
/*******************************************************************************************/
{
int color;
int zoom;
int rayon;
int curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
@ -729,21 +727,21 @@ void SEGVIA::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoi
SetAlpha( &color, 150 );
zoom = panel->GetZoom();
rayon = m_Width >> 1;
if( rayon < zoom )
rayon = zoom;
if( panel->GetScreen()->Scale( rayon ) <= 4 )
{
GRCircle( &panel->m_ClipBox, DC, m_Start.x, m_Start.y, rayon, color );
return;
}
GRCircle( &panel->m_ClipBox, DC, m_Start.x, m_Start.y, rayon, color );
if( rayon <= (4 * zoom) ) // Size too small: cannot be drawn
return;
int drill_rayon = GetDrillValue() / 2;
int inner_rayon = rayon - (2 * zoom);
int inner_rayon = rayon - panel->GetScreen()->Unscale( 2 );
GRCircle( &panel->m_ClipBox, DC, m_Start.x, m_Start.y,
inner_rayon, color );
inner_rayon, color );
// Draw the via hole if the display option allows it
if( DisplayOpt.m_DisplayViaMode != VIA_HOLE_NOT_SHOW )
@ -830,7 +828,7 @@ void SEGVIA::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoi
{
// calculate a good size for the text
int tsize = m_Width / len;
if( ( tsize / zoom) >= 6 )
if( panel->GetScreen()->Scale( tsize ) >= 6 )
{
tsize = (tsize * 8) / 10; // small reduction to give a better look, inside via
DrawGraphicText( panel, DC, m_Start,

2
pcbnew/class_zone.h
View File

@ -6,7 +6,7 @@
#define CLASS_ZONE_H
#include <vector>
#include "gr_basic.h"
#include "PolyLine.h"

14
pcbnew/classpcb.cpp
View File

@ -4,7 +4,6 @@
/**********************************************************************/
#include "fctsys.h"
#include "wxstruct.h"
#include "common.h"
#include "pcbnew.h"
@ -13,6 +12,13 @@
#include "id.h"
/* Default PCB zoom coefficients. */
static const int PcbZoomList[] = { 5, 10, 15, 20, 40, 80, 160, 320, 640, 1280,
2560, 5120, 10240, 20480 };
#define PCB_ZOOM_LIST_CNT ( sizeof( PcbZoomList ) / sizeof( int ) )
/* Default grid sizes for PCB editor screens. */
static GRID_TYPE PcbGridList[] = {
{ ID_POPUP_GRID_LEVEL_1000, wxSize( 1000, 1000 ) },
@ -40,15 +46,13 @@ PCB_SCREEN::PCB_SCREEN( ) : BASE_SCREEN( TYPE_SCREEN )
{
size_t i;
// a zero terminated list
static const int zoom_list[] = { 1, 2, 4, 8, 16, 32, 64, 128, 256,
512, 1024, 2048, 0 };
for( i = 0; i < PCB_ZOOM_LIST_CNT; i++ )
m_ZoomList.Add( PcbZoomList[i] );
for( i = 0; i < PCB_GRID_LIST_CNT; i++ )
AddGrid( PcbGridList[i] );
SetGrid( wxSize( 500, 500 ) ); /* pas de la grille en 1/10000 "*/
SetZoomList( zoom_list );
Init();
}

4
pcbnew/controle.cpp
View File

@ -482,7 +482,6 @@ void WinEDA_BasePcbFrame::GeneralControle( wxDC* DC, wxPoint Mouse )
/*****************************************************************/
{
wxSize delta;
int zoom = GetScreen()->GetZoom();
wxPoint curpos, oldpos;
int hotkey = 0;
@ -517,7 +516,8 @@ void WinEDA_BasePcbFrame::GeneralControle( wxDC* DC, wxPoint Mouse )
curpos = DrawPanel->CursorRealPosition( Mouse );
oldpos = GetScreen()->m_Curseur;
delta = GetScreen()->GetGrid() / zoom;
delta = GetScreen()->GetGrid();
GetScreen()->Scale( delta );
if( delta.x <= 0 )
delta.x = 1;

15
pcbnew/moduleframe.cpp
View File

@ -157,7 +157,6 @@ WinEDA_ModuleEditFrame::WinEDA_ModuleEditFrame( wxWindow* father,
m_Draw_Axis = TRUE; // TRUE pour avoir les axes dessines
m_Draw_Grid = TRUE; // TRUE pour avoir la axes dessinee
m_Draw_Sheet_Ref = FALSE; // TRUE pour avoir le cartouche dessin�
m_ZoomMaxValue = 1024;
// Give an icon
SetIcon( wxICON( icon_modedit ) );
@ -351,17 +350,15 @@ void WinEDA_ModuleEditFrame::SetToolbars()
if( m_SelZoomBox )
{
int old_choice = m_SelZoomBox->GetChoice();
int new_choice = 1;
int zoom;
for( jj = 1, zoom = 1; zoom <= m_ZoomMaxValue; zoom <<= 1, jj++ )
for( jj = 0; jj < GetScreen()->m_ZoomList.GetCount(); jj++ )
{
if( GetScreen() && (GetScreen()->GetZoom() == zoom) )
if( GetScreen()->GetZoom() == GetScreen()->m_ZoomList[jj] )
{
m_SelZoomBox->SetSelection( jj + 1 );
break;
new_choice++;
}
}
if( old_choice != new_choice )
m_SelZoomBox->SetSelection( new_choice );
}
if( m_SelGridBox && GetScreen() )

18
pcbnew/pcbframe.cpp
View File

@ -207,7 +207,6 @@ WinEDA_PcbFrame::WinEDA_PcbFrame( wxWindow* father,
m_SelTrackWidthBox = NULL;
m_SelViaSizeBox = NULL;
m_SelLayerBox = NULL;
m_ZoomMaxValue = 2048;
m_SelTrackWidthBox_Changed = FALSE;
m_SelViaSizeBox_Changed = FALSE;
@ -542,19 +541,14 @@ void WinEDA_PcbFrame::SetToolbars()
if( m_SelZoomBox )
{
int old_choice = m_SelZoomBox->GetChoice();
int new_choice = 1;
int zoom;
for( jj = 1, zoom = 1; zoom <= m_ZoomMaxValue; zoom <<= 1, jj++ )
for( jj = 0; jj < (int)GetScreen()->m_ZoomList.GetCount(); jj++ )
{
if( GetScreen() && (GetScreen()->GetZoom() == zoom) )
if( GetScreen()->GetZoom() == GetScreen()->m_ZoomList[jj] )
{
m_SelZoomBox->SetSelection( jj + 1 );
break;
new_choice++;
}
}
if( old_choice != new_choice )
m_SelZoomBox->SetSelection( new_choice );
}
if( m_SelGridBox && GetScreen() )
@ -575,8 +569,6 @@ void WinEDA_PcbFrame::SetToolbars()
}
UpdateToolbarLayerInfo();
PrepareLayerIndicator();
DisplayUnitsMsg();
}

4
pcbnew/tool_modedit.cpp
View File

@ -284,9 +284,9 @@ void WinEDA_ModuleEditFrame::ReCreateAuxiliaryToolbar()
wxSize( LISTBOX_WIDTH, -1 ) );
msg = _( "Auto" );
m_SelZoomBox->Append( msg );
for( int jj = 0, ii = 1; ii <= m_ZoomMaxValue; ii <<= 1, jj++ )
for( int i = 0; i < (int)GetScreen()->m_ZoomList.GetCount(); i++ )
{
msg.Printf( _( "Zoom %d" ), ii );
msg.Printf( _( "Zoom %d" ), GetScreen()->m_ZoomList[i] );
m_SelZoomBox->Append( msg );
}

5
pcbnew/tool_pcb.cpp
View File

@ -589,9 +589,10 @@ void WinEDA_PcbFrame::ReCreateAuxiliaryToolbar()
wxSize( LISTBOX_WIDTH, -1 ) );
msg = _( "Auto" );
m_SelZoomBox->Append( msg );
for( int jj = 0, ii = 1; ii <= m_ZoomMaxValue; ii <<= 1, jj++ )
for( int i = 0; i < (int)GetScreen()->m_ZoomList.GetCount(); i++ )
{
msg = _( "Zoom " ); msg << ii;
msg = _( "Zoom " );
msg << GetScreen()->m_ZoomList[i];
m_SelZoomBox->Append( msg );
}

Write Preview
Loading…
Cancel
Save