2011-11-07 19:04:24 +00:00
|
|
|
/*
|
|
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
|
|
*
|
2017-06-12 13:10:43 +00:00
|
|
|
* Copyright (C) 2004-2017 Jean-Pierre Charras, jp.charras at wanadoo.fr
|
2017-09-21 16:37:12 +00:00
|
|
|
* Copyright (C) 2008 Wayne Stambaugh <stambaughw@gmail.com>
|
2018-03-30 17:32:53 +00:00
|
|
|
* Copyright (C) 2004-2018 KiCad Developers, see AUTHORS.txt for contributors.
|
2011-11-07 19:04:24 +00:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, you may find one here:
|
|
|
|
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
|
|
* or you may search the http://www.gnu.org website for the version 2 license,
|
|
|
|
* or you may write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
|
|
*/
|
2007-05-06 16:03:28 +00:00
|
|
|
|
2011-11-07 19:04:24 +00:00
|
|
|
/**
|
2014-10-06 01:18:24 +00:00
|
|
|
* @file draw_frame.cpp
|
2011-11-07 19:04:24 +00:00
|
|
|
*/
|
2007-05-06 16:03:28 +00:00
|
|
|
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <fctsys.h>
|
* KIWAY Milestone A): Make major modules into DLL/DSOs.
! The initial testing of this commit should be done using a Debug build so that
all the wxASSERT()s are enabled. Also, be sure and keep enabled the
USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it
off is senseless anyways. If you want stable code, go back to a prior version,
the one tagged with "stable".
* Relocate all functionality out of the wxApp derivative into more finely
targeted purposes:
a) DLL/DSO specific
b) PROJECT specific
c) EXE or process specific
d) configuration file specific data
e) configuration file manipulations functions.
All of this functionality was blended into an extremely large wxApp derivative
and that was incompatible with the desire to support multiple concurrently
loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects.
An amazing amount of organization come from simply sorting each bit of
functionality into the proper box.
* Switch to wxConfigBase from wxConfig everywhere except instantiation.
* Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD,
PGM_SINGLE_TOP,
* Remove "Return" prefix on many function names.
* Remove obvious comments from CMakeLists.txt files, and from else() and endif()s.
* Fix building boost for use in a DSO on linux.
* Remove some of the assumptions in the CMakeLists.txt files that windows had
to be the host platform when building windows binaries.
* Reduce the number of wxStrings being constructed at program load time via
static construction.
* Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that
these functions are useful even when the wxConfigBase comes from another
source, as is the case in the KICAD_MANAGER_FRAME.
* Move the setting of the KIPRJMOD environment variable into class PROJECT,
so that it can be moved into a project variable soon, and out of FP_LIB_TABLE.
* Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all
its child wxFrames and wxDialogs now have a Kiway() member function which
returns a KIWAY& that that window tree branch is in support of. This is like
wxWindows DNA in that child windows get this member with proper value at time
of construction.
* Anticipate some of the needs for milestones B) and C) and make code
adjustments now in an effort to reduce work in those milestones.
* No testing has been done for python scripting, since milestone C) has that
being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
|
|
|
#include <pgm_base.h>
|
|
|
|
#include <kiface_i.h>
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <gr_basic.h>
|
|
|
|
#include <common.h>
|
|
|
|
#include <bitmaps.h>
|
|
|
|
#include <macros.h>
|
|
|
|
#include <id.h>
|
|
|
|
#include <class_drawpanel.h>
|
2018-01-29 10:37:29 +00:00
|
|
|
#include <base_screen.h>
|
2013-01-12 17:32:24 +00:00
|
|
|
#include <msgpanel.h>
|
* KIWAY Milestone A): Make major modules into DLL/DSOs.
! The initial testing of this commit should be done using a Debug build so that
all the wxASSERT()s are enabled. Also, be sure and keep enabled the
USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it
off is senseless anyways. If you want stable code, go back to a prior version,
the one tagged with "stable".
* Relocate all functionality out of the wxApp derivative into more finely
targeted purposes:
a) DLL/DSO specific
b) PROJECT specific
c) EXE or process specific
d) configuration file specific data
e) configuration file manipulations functions.
All of this functionality was blended into an extremely large wxApp derivative
and that was incompatible with the desire to support multiple concurrently
loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects.
An amazing amount of organization come from simply sorting each bit of
functionality into the proper box.
* Switch to wxConfigBase from wxConfig everywhere except instantiation.
* Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD,
PGM_SINGLE_TOP,
* Remove "Return" prefix on many function names.
* Remove obvious comments from CMakeLists.txt files, and from else() and endif()s.
* Fix building boost for use in a DSO on linux.
* Remove some of the assumptions in the CMakeLists.txt files that windows had
to be the host platform when building windows binaries.
* Reduce the number of wxStrings being constructed at program load time via
static construction.
* Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that
these functions are useful even when the wxConfigBase comes from another
source, as is the case in the KICAD_MANAGER_FRAME.
* Move the setting of the KIPRJMOD environment variable into class PROJECT,
so that it can be moved into a project variable soon, and out of FP_LIB_TABLE.
* Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all
its child wxFrames and wxDialogs now have a Kiway() member function which
returns a KIWAY& that that window tree branch is in support of. This is like
wxWindows DNA in that child windows get this member with proper value at time
of construction.
* Anticipate some of the needs for milestones B) and C) and make code
adjustments now in an effort to reduce work in those milestones.
* No testing has been done for python scripting, since milestone C) has that
being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
|
|
|
#include <draw_frame.h>
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <confirm.h>
|
|
|
|
#include <kicad_device_context.h>
|
|
|
|
#include <dialog_helpers.h>
|
2012-04-13 18:51:24 +00:00
|
|
|
#include <base_units.h>
|
2013-03-28 16:30:09 +00:00
|
|
|
#include <math/box2.h>
|
2017-02-09 08:09:28 +00:00
|
|
|
#include <lockfile.h>
|
2018-04-13 13:58:25 +00:00
|
|
|
#include <trace_helpers.h>
|
2007-05-06 16:03:28 +00:00
|
|
|
|
2018-08-03 11:51:41 +00:00
|
|
|
#include <wx/clipbrd.h>
|
|
|
|
#include <fctsys.h>
|
|
|
|
#include <gr_basic.h>
|
|
|
|
#include <common.h>
|
|
|
|
#include <id.h>
|
|
|
|
#include <base_screen.h>
|
|
|
|
#include <confirm.h>
|
|
|
|
#include <draw_frame.h>
|
|
|
|
|
|
|
|
|
2008-12-19 13:51:48 +00:00
|
|
|
#include <wx/fontdlg.h>
|
2014-09-07 19:01:26 +00:00
|
|
|
#include <wx/snglinst.h>
|
2013-04-15 15:57:03 +00:00
|
|
|
#include <view/view.h>
|
2014-03-19 13:26:02 +00:00
|
|
|
#include <view/view_controls.h>
|
2013-04-15 15:57:03 +00:00
|
|
|
#include <gal/graphics_abstraction_layer.h>
|
2015-04-30 08:46:02 +00:00
|
|
|
#include <tool/tool_manager.h>
|
|
|
|
#include <tool/tool_dispatcher.h>
|
2017-02-21 12:42:08 +00:00
|
|
|
#include <tool/actions.h>
|
2007-05-06 16:03:28 +00:00
|
|
|
|
2018-12-12 14:16:50 +00:00
|
|
|
#include <advanced_config.h>
|
2018-08-03 11:51:41 +00:00
|
|
|
#include <menus_helpers.h>
|
|
|
|
#include <page_info.h>
|
|
|
|
#include <title_block.h>
|
2018-12-12 14:16:50 +00:00
|
|
|
#include <worksheet_shape_builder.h>
|
2018-08-03 11:51:41 +00:00
|
|
|
|
2011-11-07 19:04:24 +00:00
|
|
|
/**
|
|
|
|
* Definition for enabling and disabling scroll bar setting trace output. See the
|
|
|
|
* wxWidgets documentation on useing the WXTRACE environment variable.
|
2010-02-22 16:45:35 +00:00
|
|
|
*/
|
2011-11-07 19:04:24 +00:00
|
|
|
static const wxString traceScrollSettings( wxT( "KicadScrollSettings" ) );
|
2010-02-22 16:45:35 +00:00
|
|
|
|
|
|
|
|
2016-05-12 19:45:47 +00:00
|
|
|
///@{
|
|
|
|
/// \ingroup config
|
2018-01-04 14:28:02 +00:00
|
|
|
static const wxString FirstRunShownKeyword( wxT( "FirstRunShown" ) );
|
2017-09-20 08:53:58 +00:00
|
|
|
|
2016-05-12 19:45:47 +00:00
|
|
|
///@}
|
|
|
|
|
2016-05-12 16:51:32 +00:00
|
|
|
/**
|
|
|
|
* Integer to set the maximum number of undo items on the stack. If zero,
|
|
|
|
* undo items are unlimited.
|
|
|
|
*
|
|
|
|
* Present as:
|
|
|
|
*
|
|
|
|
* - SchematicFrameDevelMaxUndoItems (file: eeschema)
|
|
|
|
* - LibeditFrameDevelMaxUndoItems (file: eeschema)
|
|
|
|
* - PcbFrameDevelMaxUndoItems (file: pcbnew)
|
|
|
|
* - ModEditFrameDevelMaxUndoItems (file: pcbnew)
|
|
|
|
*
|
|
|
|
* \ingroup develconfig
|
|
|
|
*/
|
|
|
|
static const wxString MaxUndoItemsEntry(wxT( "DevelMaxUndoItems" ) );
|
2009-04-05 20:49:15 +00:00
|
|
|
|
2014-04-21 06:28:17 +00:00
|
|
|
BEGIN_EVENT_TABLE( EDA_DRAW_FRAME, KIWAY_PLAYER )
|
2017-10-06 07:23:13 +00:00
|
|
|
EVT_CHAR_HOOK( EDA_DRAW_FRAME::OnCharHook )
|
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
EVT_MOUSEWHEEL( EDA_DRAW_FRAME::OnMouseEvent )
|
|
|
|
EVT_MENU_OPEN( EDA_DRAW_FRAME::OnMenuOpen )
|
|
|
|
EVT_ACTIVATE( EDA_DRAW_FRAME::OnActivate )
|
2014-10-15 11:40:38 +00:00
|
|
|
EVT_MENU_RANGE( ID_ZOOM_BEGIN, ID_ZOOM_END, EDA_DRAW_FRAME::OnZoom )
|
|
|
|
|
2009-01-07 15:59:49 +00:00
|
|
|
EVT_MENU_RANGE( ID_POPUP_ZOOM_START_RANGE, ID_POPUP_ZOOM_END_RANGE,
|
2011-01-21 19:30:59 +00:00
|
|
|
EDA_DRAW_FRAME::OnZoom )
|
2014-10-15 11:40:38 +00:00
|
|
|
|
2009-10-14 19:43:31 +00:00
|
|
|
EVT_MENU_RANGE( ID_POPUP_GRID_LEVEL_1000, ID_POPUP_GRID_USER,
|
2011-01-21 19:30:59 +00:00
|
|
|
EDA_DRAW_FRAME::OnSelectGrid )
|
2011-02-21 13:54:29 +00:00
|
|
|
|
|
|
|
EVT_TOOL( ID_TB_OPTIONS_SHOW_GRID, EDA_DRAW_FRAME::OnToggleGridState )
|
|
|
|
EVT_TOOL_RANGE( ID_TB_OPTIONS_SELECT_UNIT_MM, ID_TB_OPTIONS_SELECT_UNIT_INCH,
|
|
|
|
EDA_DRAW_FRAME::OnSelectUnits )
|
2016-05-11 03:33:24 +00:00
|
|
|
|
2011-02-21 13:54:29 +00:00
|
|
|
EVT_TOOL( ID_TB_OPTIONS_SELECT_CURSOR, EDA_DRAW_FRAME::OnToggleCrossHairStyle )
|
|
|
|
|
|
|
|
EVT_UPDATE_UI( wxID_UNDO, EDA_DRAW_FRAME::OnUpdateUndo )
|
|
|
|
EVT_UPDATE_UI( wxID_REDO, EDA_DRAW_FRAME::OnUpdateRedo )
|
|
|
|
EVT_UPDATE_UI( ID_TB_OPTIONS_SHOW_GRID, EDA_DRAW_FRAME::OnUpdateGrid )
|
|
|
|
EVT_UPDATE_UI( ID_TB_OPTIONS_SELECT_CURSOR, EDA_DRAW_FRAME::OnUpdateCrossHairStyle )
|
|
|
|
EVT_UPDATE_UI_RANGE( ID_TB_OPTIONS_SELECT_UNIT_MM, ID_TB_OPTIONS_SELECT_UNIT_INCH,
|
|
|
|
EDA_DRAW_FRAME::OnUpdateUnits )
|
2009-01-07 15:59:49 +00:00
|
|
|
END_EVENT_TABLE()
|
|
|
|
|
|
|
|
|
* KIWAY Milestone A): Make major modules into DLL/DSOs.
! The initial testing of this commit should be done using a Debug build so that
all the wxASSERT()s are enabled. Also, be sure and keep enabled the
USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it
off is senseless anyways. If you want stable code, go back to a prior version,
the one tagged with "stable".
* Relocate all functionality out of the wxApp derivative into more finely
targeted purposes:
a) DLL/DSO specific
b) PROJECT specific
c) EXE or process specific
d) configuration file specific data
e) configuration file manipulations functions.
All of this functionality was blended into an extremely large wxApp derivative
and that was incompatible with the desire to support multiple concurrently
loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects.
An amazing amount of organization come from simply sorting each bit of
functionality into the proper box.
* Switch to wxConfigBase from wxConfig everywhere except instantiation.
* Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD,
PGM_SINGLE_TOP,
* Remove "Return" prefix on many function names.
* Remove obvious comments from CMakeLists.txt files, and from else() and endif()s.
* Fix building boost for use in a DSO on linux.
* Remove some of the assumptions in the CMakeLists.txt files that windows had
to be the host platform when building windows binaries.
* Reduce the number of wxStrings being constructed at program load time via
static construction.
* Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that
these functions are useful even when the wxConfigBase comes from another
source, as is the case in the KICAD_MANAGER_FRAME.
* Move the setting of the KIPRJMOD environment variable into class PROJECT,
so that it can be moved into a project variable soon, and out of FP_LIB_TABLE.
* Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all
its child wxFrames and wxDialogs now have a Kiway() member function which
returns a KIWAY& that that window tree branch is in support of. This is like
wxWindows DNA in that child windows get this member with proper value at time
of construction.
* Anticipate some of the needs for milestones B) and C) and make code
adjustments now in an effort to reduce work in those milestones.
* No testing has been done for python scripting, since milestone C) has that
being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
|
|
|
EDA_DRAW_FRAME::EDA_DRAW_FRAME( KIWAY* aKiway, wxWindow* aParent,
|
2014-04-19 18:47:20 +00:00
|
|
|
FRAME_T aFrameType,
|
2012-09-12 09:53:11 +00:00
|
|
|
const wxString& aTitle,
|
|
|
|
const wxPoint& aPos, const wxSize& aSize,
|
|
|
|
long aStyle, const wxString & aFrameName ) :
|
2018-08-28 22:32:36 +00:00
|
|
|
KIWAY_PLAYER( aKiway, aParent, aFrameType, aTitle, aPos, aSize, aStyle, aFrameName )
|
2007-08-15 02:43:57 +00:00
|
|
|
{
|
2018-04-04 11:01:47 +00:00
|
|
|
m_socketServer = nullptr;
|
2011-12-14 20:03:15 +00:00
|
|
|
m_drawToolBar = NULL;
|
|
|
|
m_optionsToolBar = NULL;
|
2018-04-03 11:00:20 +00:00
|
|
|
m_auxiliaryToolBar = NULL;
|
2011-12-14 20:03:15 +00:00
|
|
|
m_gridSelectBox = NULL;
|
|
|
|
m_zoomSelectBox = NULL;
|
2015-05-19 16:39:05 +00:00
|
|
|
m_hotkeysDescrList = NULL;
|
2009-01-29 14:26:20 +00:00
|
|
|
|
2011-12-22 13:28:11 +00:00
|
|
|
m_canvas = NULL;
|
2018-01-12 04:02:18 +00:00
|
|
|
m_canvasType = EDA_DRAW_PANEL_GAL::GAL_TYPE_NONE;
|
Introduction of Graphics Abstraction Layer based rendering for pcbnew.
New classes:
- VIEW - represents view that is seen by user, takes care of layer ordering & visibility and how it is displayed (which location, how much zoomed, etc.)
- VIEW_ITEM - Base class for every item that can be displayed on VIEW (the biggest change is that now it may be necessary to override ViewBBox & ViewGetLayers method for derived classes).
- EDA_DRAW_PANEL_GAL - Inherits after EDA_DRAW_PANEL, displays VIEW output, right now it is not editable (in opposite to usual EDA_DRAW_PANEL).
- GAL/OPENGL_GAL/CAIRO_GAL - Base Graphics Abstraction Layer class + two different flavours (Cairo is not fully supported yet), that offers methods to draw primitives using different libraries.
- WX_VIEW_CONTROLS - Controller for VIEW, handles user events, allows zooming, panning, etc.
- PAINTER/PCB_PAINTER - Classes that uses GAL interface to draw items (as you may have already guessed - PCB_PAINTER is a class for drawing PCB specific object, PAINTER is an abstract class). Its methods are invoked by VIEW, when an item has to be drawn. To display a new type of item - you need to implement draw(ITEM_TYPE*) method that draws it using GAL methods.
- STROKE_FONT - Implements stroke font drawing using GAL methods.
Most important changes to Kicad original code:
* EDA_ITEM now inherits from VIEW_ITEM, which is a base class for all drawable objects.
* EDA_DRAW_FRAME contains both usual EDA_DRAW_PANEL and new EDA_DRAW_PANEL_GAL, that can be switched anytime.
* There are some new layers for displaying multilayer pads, vias & pads holes (these are not shown yet on the right sidebar in pcbnew)
* Display order of layers is different than in previous versions (if you are curious - you may check m_galLayerOrder@pcbnew/basepcbframe.cpp). Preserving usual order would result in not very natural display, such as showing silkscreen texts on the bottom.
* Introduced new hotkey (Alt+F12) and new menu option (View->Switch canvas) for switching canvas during runtime.
* Some of classes (mostly derived from BOARD_ITEM) now includes ViewBBox & ViewGetLayers methods.
* Removed tools/class_painter.h, as now it is extended and included in source code.
Build changes:
* GAL-based rendering option is turned on by a new compilation CMake option KICAD_GAL.
* When compiling with CMake option KICAD_GAL=ON, GLEW and Cairo libraries are required.
* GAL-related code is compiled into a static library (common/libgal).
* Build with KICAD_GAL=OFF should not need any new libraries and should come out as a standard version of Kicad
Currently most of items in pcbnew can be displayed using OpenGL (to be done are DIMENSIONS and MARKERS).
More details about GAL can be found in: http://www.ohwr.org/attachments/1884/view-spec.pdf
2013-04-02 06:54:03 +00:00
|
|
|
m_galCanvas = NULL;
|
|
|
|
m_galCanvasActive = false;
|
2017-02-21 12:42:08 +00:00
|
|
|
m_actions = NULL;
|
2015-04-30 08:46:02 +00:00
|
|
|
m_toolManager = NULL;
|
|
|
|
m_toolDispatcher = NULL;
|
2011-12-12 14:02:37 +00:00
|
|
|
m_messagePanel = NULL;
|
2011-02-05 02:21:11 +00:00
|
|
|
m_currentScreen = NULL;
|
2011-02-24 20:22:12 +00:00
|
|
|
m_toolId = ID_NO_TOOL_SELECTED;
|
2011-12-14 20:03:15 +00:00
|
|
|
m_lastDrawToolId = ID_NO_TOOL_SELECTED;
|
|
|
|
m_showAxis = false; // true to draw axis.
|
|
|
|
m_showBorderAndTitleBlock = false; // true to display reference sheet.
|
|
|
|
m_showGridAxis = false; // true to draw the grid axis
|
2014-08-12 14:39:44 +00:00
|
|
|
m_showOriginAxis = false; // true to draw the grid origin
|
2009-10-14 19:43:31 +00:00
|
|
|
m_LastGridSizeId = 0;
|
2014-09-26 10:35:11 +00:00
|
|
|
m_drawGrid = true; // hide/Show grid. default = show
|
2017-02-20 16:57:41 +00:00
|
|
|
m_gridColor = COLOR4D( DARKGRAY ); // Default grid color
|
2014-06-20 11:13:04 +00:00
|
|
|
m_showPageLimits = false;
|
2017-02-20 16:57:41 +00:00
|
|
|
m_drawBgColor = COLOR4D( BLACK ); // the background color of the draw canvas:
|
|
|
|
// BLACK for Pcbnew, BLACK or WHITE for eeschema
|
2011-02-03 19:27:28 +00:00
|
|
|
m_snapToGrid = true;
|
2013-01-12 17:32:24 +00:00
|
|
|
m_MsgFrameHeight = EDA_MSG_PANEL::GetRequiredHeight();
|
2014-06-12 16:12:14 +00:00
|
|
|
m_movingCursorWithKeyboard = false;
|
2015-01-06 07:38:58 +00:00
|
|
|
m_zoomLevelCoeff = 1.0;
|
2013-01-12 17:32:24 +00:00
|
|
|
|
2018-01-11 22:01:46 +00:00
|
|
|
m_auimgr.SetFlags(wxAUI_MGR_DEFAULT);
|
2014-01-13 15:09:52 +00:00
|
|
|
|
2019-06-10 14:16:14 +00:00
|
|
|
CreateStatusBar( 7 );
|
2012-05-06 23:32:01 +00:00
|
|
|
|
|
|
|
// set the size of the status bar subwindows:
|
|
|
|
|
|
|
|
wxWindow* stsbar = GetStatusBar();
|
|
|
|
|
|
|
|
int dims[] = {
|
|
|
|
|
2013-08-03 05:15:23 +00:00
|
|
|
// remainder of status bar on far left is set to a default or whatever is left over.
|
2012-05-06 23:32:01 +00:00
|
|
|
-1,
|
|
|
|
|
2013-08-03 05:15:23 +00:00
|
|
|
// When using GetTextSize() remember the width of character '1' is not the same
|
2012-05-06 23:32:01 +00:00
|
|
|
// as the width of '0' unless the font is fixed width, and it usually won't be.
|
|
|
|
|
|
|
|
// zoom:
|
|
|
|
GetTextSize( wxT( "Z 762000" ), stsbar ).x + 10,
|
|
|
|
|
|
|
|
// cursor coords
|
|
|
|
GetTextSize( wxT( "X 0234.567890 Y 0234.567890" ), stsbar ).x + 10,
|
|
|
|
|
|
|
|
// delta distances
|
|
|
|
GetTextSize( wxT( "dx 0234.567890 dx 0234.567890 d 0234.567890" ), stsbar ).x + 10,
|
|
|
|
|
2019-06-10 14:16:14 +00:00
|
|
|
// grid size
|
|
|
|
GetTextSize( wxT( "grid X 0234.567890 Y 0234.567890" ), stsbar ).x + 10,
|
|
|
|
|
2012-05-06 23:32:01 +00:00
|
|
|
// units display, Inches is bigger than mm
|
2012-05-19 19:04:03 +00:00
|
|
|
GetTextSize( _( "Inches" ), stsbar ).x + 10,
|
2012-05-06 23:32:01 +00:00
|
|
|
|
2013-08-03 05:15:23 +00:00
|
|
|
// Size for the panel used as "Current tool in play": will take longest string from
|
|
|
|
// void PCB_EDIT_FRAME::OnSelectTool( wxCommandEvent& aEvent ) in pcbnew/edit.cpp
|
|
|
|
GetTextSize( wxT( "Add layer alignment target" ), stsbar ).x + 10,
|
2012-05-06 23:32:01 +00:00
|
|
|
};
|
|
|
|
|
2019-01-06 16:43:12 +00:00
|
|
|
SetStatusWidths( arrayDim( dims ), dims );
|
2007-08-15 02:43:57 +00:00
|
|
|
|
|
|
|
// Create child subwindows.
|
2009-11-23 15:16:50 +00:00
|
|
|
GetClientSize( &m_FrameSize.x, &m_FrameSize.y );
|
2007-08-15 02:43:57 +00:00
|
|
|
m_FramePos.x = m_FramePos.y = 0;
|
|
|
|
m_FrameSize.y -= m_MsgFrameHeight;
|
|
|
|
|
2011-12-22 13:28:11 +00:00
|
|
|
m_canvas = new EDA_DRAW_PANEL( this, -1, wxPoint( 0, 0 ), m_FrameSize );
|
2011-12-12 14:02:37 +00:00
|
|
|
m_messagePanel = new EDA_MSG_PANEL( this, -1, wxPoint( 0, m_FrameSize.y ),
|
|
|
|
wxSize( m_FrameSize.x, m_MsgFrameHeight ) );
|
2009-04-09 18:23:28 +00:00
|
|
|
|
2017-02-20 16:57:41 +00:00
|
|
|
m_messagePanel->SetBackgroundColour( COLOR4D( LIGHTGRAY ).ToColour() );
|
2007-05-06 16:03:28 +00:00
|
|
|
}
|
|
|
|
|
2007-08-15 02:43:57 +00:00
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
EDA_DRAW_FRAME::~EDA_DRAW_FRAME()
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
2018-04-04 11:01:47 +00:00
|
|
|
delete m_socketServer;
|
|
|
|
for( auto socket : m_sockets )
|
|
|
|
{
|
|
|
|
socket->Shutdown();
|
|
|
|
socket->Destroy();
|
|
|
|
}
|
|
|
|
|
2019-01-09 13:31:46 +00:00
|
|
|
saveCanvasTypeSetting( m_canvasType );
|
2018-01-12 04:02:18 +00:00
|
|
|
|
2017-02-21 12:42:08 +00:00
|
|
|
delete m_actions;
|
2015-04-30 08:46:02 +00:00
|
|
|
delete m_toolManager;
|
|
|
|
delete m_toolDispatcher;
|
|
|
|
delete m_galCanvas;
|
|
|
|
|
2013-04-28 14:28:13 +00:00
|
|
|
delete m_currentScreen;
|
|
|
|
m_currentScreen = NULL;
|
2009-11-05 08:52:41 +00:00
|
|
|
|
2009-11-02 22:24:55 +00:00
|
|
|
m_auimgr.UnInit();
|
2014-09-07 19:01:26 +00:00
|
|
|
|
|
|
|
ReleaseFile();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-10-06 07:23:13 +00:00
|
|
|
void EDA_DRAW_FRAME::OnCharHook( wxKeyEvent& event )
|
|
|
|
{
|
2018-04-13 13:58:25 +00:00
|
|
|
wxLogTrace( kicadTraceKeyEvent, "EDA_DRAW_FRAME::OnCharHook %s", dump( event ) );
|
2017-10-06 07:23:13 +00:00
|
|
|
// Key events can be filtered here.
|
|
|
|
// Currently no filtering is made.
|
|
|
|
event.Skip();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-09-07 19:01:26 +00:00
|
|
|
void EDA_DRAW_FRAME::ReleaseFile()
|
|
|
|
{
|
2017-02-09 08:09:28 +00:00
|
|
|
m_file_checker = nullptr;
|
2014-09-07 19:01:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool EDA_DRAW_FRAME::LockFile( const wxString& aFileName )
|
|
|
|
{
|
|
|
|
m_file_checker = ::LockFile( aFileName );
|
|
|
|
|
|
|
|
return bool( m_file_checker );
|
2007-05-06 16:03:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-03-11 15:53:28 +00:00
|
|
|
void EDA_DRAW_FRAME::unitsChangeRefresh()
|
|
|
|
{
|
|
|
|
UpdateStatusBar();
|
2015-07-03 18:58:12 +00:00
|
|
|
UpdateMsgPanel();
|
2011-03-11 15:53:28 +00:00
|
|
|
}
|
|
|
|
|
2018-05-14 17:34:18 +00:00
|
|
|
void EDA_DRAW_FRAME::CommonSettingsChanged()
|
|
|
|
{
|
|
|
|
EDA_BASE_FRAME::CommonSettingsChanged();
|
|
|
|
|
2018-09-04 00:00:17 +00:00
|
|
|
wxConfigBase* settings = Pgm().CommonSettings();
|
|
|
|
|
2018-08-20 13:46:38 +00:00
|
|
|
int autosaveInterval;
|
2018-09-04 00:00:17 +00:00
|
|
|
settings->Read( AUTOSAVE_INTERVAL_KEY, &autosaveInterval );
|
2018-08-20 13:46:38 +00:00
|
|
|
SetAutoSaveInterval( autosaveInterval );
|
|
|
|
|
|
|
|
int historySize;
|
2018-09-04 00:00:17 +00:00
|
|
|
settings->Read( FILE_HISTORY_SIZE_KEY, &historySize, DEFAULT_FILE_HISTORY_SIZE );
|
2018-08-20 13:46:38 +00:00
|
|
|
Kiface().GetFileHistory().SetMaxFiles( (unsigned) std::max( 0, historySize ) );
|
|
|
|
|
2018-05-14 17:34:18 +00:00
|
|
|
bool option;
|
2018-09-04 00:00:17 +00:00
|
|
|
settings->Read( ENBL_MOUSEWHEEL_PAN_KEY, &option );
|
2018-05-14 17:34:18 +00:00
|
|
|
m_canvas->SetEnableMousewheelPan( option );
|
|
|
|
|
2018-09-04 00:00:17 +00:00
|
|
|
settings->Read( ENBL_ZOOM_NO_CENTER_KEY, &option );
|
2018-05-14 17:34:18 +00:00
|
|
|
m_canvas->SetEnableZoomNoCenter( option );
|
|
|
|
|
2018-09-04 00:00:17 +00:00
|
|
|
settings->Read( ENBL_AUTO_PAN_KEY, &option );
|
2018-05-14 17:34:18 +00:00
|
|
|
m_canvas->SetEnableAutoPan( option );
|
2018-08-28 22:32:36 +00:00
|
|
|
|
2019-04-11 19:35:52 +00:00
|
|
|
m_galDisplayOptions.ReadCommonConfig( *settings, this );
|
2018-05-14 17:34:18 +00:00
|
|
|
}
|
|
|
|
|
2011-03-11 15:53:28 +00:00
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::EraseMsgBox()
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
2011-12-12 14:02:37 +00:00
|
|
|
if( m_messagePanel )
|
|
|
|
m_messagePanel->EraseMsgBox();
|
2007-05-06 16:03:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::OnActivate( wxActivateEvent& event )
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
2011-12-22 13:28:11 +00:00
|
|
|
if( m_canvas )
|
2011-12-29 20:11:42 +00:00
|
|
|
m_canvas->SetCanStartBlock( -1 );
|
2007-05-06 16:03:28 +00:00
|
|
|
|
2007-08-15 02:43:57 +00:00
|
|
|
event.Skip(); // required under wxMAC
|
2007-05-06 16:03:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::OnMenuOpen( wxMenuEvent& event )
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
2011-12-22 13:28:11 +00:00
|
|
|
if( m_canvas )
|
2011-12-29 20:11:42 +00:00
|
|
|
m_canvas->SetCanStartBlock( -1 );
|
2011-01-31 18:26:12 +00:00
|
|
|
|
2007-08-15 02:43:57 +00:00
|
|
|
event.Skip();
|
2007-05-06 16:03:28 +00:00
|
|
|
}
|
|
|
|
|
2014-08-29 20:23:40 +00:00
|
|
|
|
2012-12-07 10:05:19 +00:00
|
|
|
void EDA_DRAW_FRAME::SkipNextLeftButtonReleaseEvent()
|
2012-12-06 21:53:00 +00:00
|
|
|
{
|
|
|
|
m_canvas->SetIgnoreLeftButtonReleaseEvent( true );
|
|
|
|
}
|
2007-05-06 16:03:28 +00:00
|
|
|
|
2014-08-29 20:23:40 +00:00
|
|
|
|
2011-02-21 13:54:29 +00:00
|
|
|
void EDA_DRAW_FRAME::OnToggleGridState( wxCommandEvent& aEvent )
|
|
|
|
{
|
|
|
|
SetGridVisibility( !IsGridVisible() );
|
2014-08-29 20:23:40 +00:00
|
|
|
|
2013-12-26 22:36:43 +00:00
|
|
|
if( IsGalCanvasActive() )
|
2013-09-06 15:06:02 +00:00
|
|
|
{
|
2013-12-26 22:36:43 +00:00
|
|
|
GetGalCanvas()->GetGAL()->SetGridVisibility( IsGridVisible() );
|
|
|
|
GetGalCanvas()->GetView()->MarkTargetDirty( KIGFX::TARGET_NONCACHED );
|
2013-09-06 15:06:02 +00:00
|
|
|
}
|
2013-09-06 09:31:16 +00:00
|
|
|
|
2013-09-20 15:29:32 +00:00
|
|
|
m_canvas->Refresh();
|
2011-02-21 13:54:29 +00:00
|
|
|
}
|
|
|
|
|
2018-11-09 13:32:13 +00:00
|
|
|
|
2018-04-03 11:00:20 +00:00
|
|
|
bool EDA_DRAW_FRAME::GetToolToggled( int aToolId )
|
|
|
|
{
|
|
|
|
// Checks all the toolbars and returns true if the given tool id is toggled.
|
|
|
|
return ( ( m_mainToolBar && m_mainToolBar->GetToolToggled( aToolId ) ) ||
|
|
|
|
( m_optionsToolBar && m_optionsToolBar->GetToolToggled( aToolId ) ) ||
|
|
|
|
( m_drawToolBar && m_drawToolBar->GetToolToggled( aToolId ) ) ||
|
|
|
|
( m_auxiliaryToolBar && m_auxiliaryToolBar->GetToolToggled( aToolId ) )
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
wxAuiToolBarItem* EDA_DRAW_FRAME::GetToolbarTool( int aToolId )
|
|
|
|
{
|
|
|
|
// Checks all the toolbars and returns a reference to the given tool id
|
|
|
|
// (or the first tool found, but only one or 0 tool is expected, because on
|
|
|
|
// Windows, when different tools have the same ID, it creates issues)
|
|
|
|
if( m_mainToolBar && m_mainToolBar->FindTool( aToolId ) )
|
|
|
|
return m_mainToolBar->FindTool( aToolId );
|
|
|
|
|
|
|
|
if( m_optionsToolBar && m_optionsToolBar->FindTool( aToolId ) )
|
|
|
|
return m_optionsToolBar->FindTool( aToolId );
|
|
|
|
|
|
|
|
if( m_drawToolBar && m_drawToolBar->FindTool( aToolId ) )
|
|
|
|
return m_drawToolBar->FindTool( aToolId );
|
|
|
|
|
|
|
|
if( m_auxiliaryToolBar && m_auxiliaryToolBar->FindTool( aToolId ) )
|
|
|
|
return m_auxiliaryToolBar->FindTool( aToolId );
|
|
|
|
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2011-02-21 13:54:29 +00:00
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::OnSelectUnits( wxCommandEvent& aEvent )
|
|
|
|
{
|
2018-02-02 15:44:53 +00:00
|
|
|
if( aEvent.GetId() == ID_TB_OPTIONS_SELECT_UNIT_MM && m_UserUnits != MILLIMETRES )
|
2011-02-21 13:54:29 +00:00
|
|
|
{
|
2018-02-02 15:44:53 +00:00
|
|
|
m_UserUnits = MILLIMETRES;
|
2011-03-01 19:26:17 +00:00
|
|
|
unitsChangeRefresh();
|
2011-02-21 13:54:29 +00:00
|
|
|
}
|
2018-02-02 15:44:53 +00:00
|
|
|
else if( aEvent.GetId() == ID_TB_OPTIONS_SELECT_UNIT_INCH && m_UserUnits != INCHES )
|
2011-02-21 13:54:29 +00:00
|
|
|
{
|
2018-02-02 15:44:53 +00:00
|
|
|
m_UserUnits = INCHES;
|
2011-03-01 19:26:17 +00:00
|
|
|
unitsChangeRefresh();
|
2011-02-21 13:54:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::OnToggleCrossHairStyle( wxCommandEvent& aEvent )
|
|
|
|
{
|
2011-12-22 13:28:11 +00:00
|
|
|
INSTALL_UNBUFFERED_DC( dc, m_canvas );
|
|
|
|
m_canvas->CrossHairOff( &dc );
|
2017-03-19 20:51:59 +00:00
|
|
|
|
|
|
|
auto& galOpts = GetGalDisplayOptions();
|
|
|
|
galOpts.m_fullscreenCursor = !galOpts.m_fullscreenCursor;
|
|
|
|
galOpts.NotifyChanged();
|
|
|
|
|
2011-12-22 13:28:11 +00:00
|
|
|
m_canvas->CrossHairOn( &dc );
|
2011-02-21 13:54:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::OnUpdateUndo( wxUpdateUIEvent& aEvent )
|
|
|
|
{
|
|
|
|
if( GetScreen() )
|
|
|
|
aEvent.Enable( GetScreen()->GetUndoCommandCount() > 0 );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::OnUpdateRedo( wxUpdateUIEvent& aEvent )
|
|
|
|
{
|
|
|
|
if( GetScreen() )
|
|
|
|
aEvent.Enable( GetScreen()->GetRedoCommandCount() > 0 );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::OnUpdateUnits( wxUpdateUIEvent& aEvent )
|
|
|
|
{
|
|
|
|
bool enable;
|
|
|
|
|
2018-02-02 15:44:53 +00:00
|
|
|
enable = ( ((aEvent.GetId() == ID_TB_OPTIONS_SELECT_UNIT_MM) && (m_UserUnits == MILLIMETRES))
|
|
|
|
|| ((aEvent.GetId() == ID_TB_OPTIONS_SELECT_UNIT_INCH) && (m_UserUnits == INCHES)) );
|
2011-02-21 13:54:29 +00:00
|
|
|
|
|
|
|
aEvent.Check( enable );
|
|
|
|
DisplayUnitsMsg();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::OnUpdateGrid( wxUpdateUIEvent& aEvent )
|
|
|
|
{
|
|
|
|
wxString tool_tip = IsGridVisible() ? _( "Hide grid" ) : _( "Show grid" );
|
|
|
|
|
|
|
|
aEvent.Check( IsGridVisible() );
|
2011-12-14 20:03:15 +00:00
|
|
|
m_optionsToolBar->SetToolShortHelp( ID_TB_OPTIONS_SHOW_GRID, tool_tip );
|
2011-02-21 13:54:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-11-17 00:33:20 +00:00
|
|
|
void EDA_DRAW_FRAME::OnUpdateSelectGrid( wxUpdateUIEvent& aEvent )
|
|
|
|
{
|
|
|
|
// No need to update the grid select box if it doesn't exist or the grid setting change
|
|
|
|
// was made using the select box.
|
|
|
|
if( m_gridSelectBox == NULL || m_auxiliaryToolBar == NULL )
|
|
|
|
return;
|
|
|
|
|
|
|
|
int select = wxNOT_FOUND;
|
|
|
|
|
|
|
|
for( size_t i = 0; i < GetScreen()->GetGridCount(); i++ )
|
|
|
|
{
|
|
|
|
if( GetScreen()->GetGridCmdId() == GetScreen()->GetGrid( i ).m_CmdId )
|
|
|
|
{
|
|
|
|
select = (int) i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if( select != m_gridSelectBox->GetSelection() )
|
|
|
|
m_gridSelectBox->SetSelection( select );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 13:54:29 +00:00
|
|
|
void EDA_DRAW_FRAME::OnUpdateCrossHairStyle( wxUpdateUIEvent& aEvent )
|
|
|
|
{
|
2017-03-19 20:51:59 +00:00
|
|
|
aEvent.Check( GetGalDisplayOptions().m_fullscreenCursor );
|
2011-02-21 13:54:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::ReCreateAuxiliaryToolbar()
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2007-08-15 02:43:57 +00:00
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::ReCreateMenuBar()
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2007-08-15 02:43:57 +00:00
|
|
|
|
2014-08-29 20:23:40 +00:00
|
|
|
bool EDA_DRAW_FRAME::OnHotKey( wxDC* aDC, int aHotKey, const wxPoint& aPosition, EDA_ITEM* aItem )
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
2014-08-29 20:23:40 +00:00
|
|
|
return false;
|
2007-05-06 16:03:28 +00:00
|
|
|
}
|
|
|
|
|
2018-11-09 13:32:13 +00:00
|
|
|
int EDA_DRAW_FRAME::WriteHotkeyConfig( struct EDA_HOTKEY_CONFIG* aDescList,
|
|
|
|
wxString* aFullFileName )
|
2015-05-05 18:39:42 +00:00
|
|
|
{
|
|
|
|
int result = EDA_BASE_FRAME::WriteHotkeyConfig( aDescList, aFullFileName );
|
|
|
|
|
|
|
|
if( IsGalCanvasActive() )
|
|
|
|
GetToolManager()->UpdateHotKeys();
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2007-05-06 16:03:28 +00:00
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::ToolOnRightClick( wxCommandEvent& event )
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2011-02-21 13:54:29 +00:00
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
void EDA_DRAW_FRAME::PrintPage( wxDC* aDC, LSET aPrintMask, bool aPrintMirrorMode, void* aData )
|
2010-03-18 20:35:29 +00:00
|
|
|
{
|
2011-02-11 20:48:13 +00:00
|
|
|
wxMessageBox( wxT("EDA_DRAW_FRAME::PrintPage() error") );
|
2010-03-18 20:35:29 +00:00
|
|
|
}
|
2007-08-15 02:43:57 +00:00
|
|
|
|
2011-01-31 18:26:12 +00:00
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::OnSelectGrid( wxCommandEvent& event )
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
2009-10-14 19:43:31 +00:00
|
|
|
int* clientData;
|
2014-02-02 19:51:50 +00:00
|
|
|
int eventId = ID_POPUP_GRID_LEVEL_100;
|
2009-10-14 19:43:31 +00:00
|
|
|
|
2019-01-28 14:15:32 +00:00
|
|
|
if( event.GetEventType() == wxEVT_CHOICE )
|
2009-10-14 19:43:31 +00:00
|
|
|
{
|
2015-05-12 09:05:36 +00:00
|
|
|
if( m_gridSelectBox == NULL ) // Should not happen
|
2009-10-14 19:43:31 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't use wxCommandEvent::GetClientData() here. It always
|
|
|
|
* returns NULL in GTK. This solution is not as elegant but
|
|
|
|
* it works.
|
|
|
|
*/
|
2011-12-14 20:03:15 +00:00
|
|
|
int index = m_gridSelectBox->GetSelection();
|
2009-10-14 19:43:31 +00:00
|
|
|
wxASSERT( index != wxNOT_FOUND );
|
2018-11-17 00:33:20 +00:00
|
|
|
|
2019-05-25 21:14:20 +00:00
|
|
|
// GerbView does not support custom grid
|
|
|
|
if( m_Ident != FRAME_GERBER )
|
2018-11-17 00:33:20 +00:00
|
|
|
{
|
2019-05-25 21:14:20 +00:00
|
|
|
if( index == int( m_gridSelectBox->GetCount() - 2 ) )
|
|
|
|
{
|
|
|
|
// this is the separator
|
|
|
|
wxUpdateUIEvent dummy;
|
|
|
|
OnUpdateSelectGrid( dummy );
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else if( index == int( m_gridSelectBox->GetCount() - 1 ) )
|
|
|
|
{
|
|
|
|
wxUpdateUIEvent dummy;
|
|
|
|
OnUpdateSelectGrid( dummy );
|
|
|
|
wxCommandEvent dummy2;
|
|
|
|
OnGridSettings( dummy2 );
|
|
|
|
return;
|
|
|
|
}
|
2018-11-17 00:33:20 +00:00
|
|
|
}
|
|
|
|
|
2011-12-14 20:03:15 +00:00
|
|
|
clientData = (int*) m_gridSelectBox->wxItemContainer::GetClientData( index );
|
2009-10-14 19:43:31 +00:00
|
|
|
|
|
|
|
if( clientData != NULL )
|
2014-02-02 19:51:50 +00:00
|
|
|
eventId = *clientData;
|
2009-10-14 19:43:31 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-02-02 19:51:50 +00:00
|
|
|
eventId = event.GetId();
|
2009-10-14 19:43:31 +00:00
|
|
|
}
|
2007-05-06 16:03:28 +00:00
|
|
|
|
2015-04-30 08:46:04 +00:00
|
|
|
int idx = eventId - ID_POPUP_GRID_LEVEL_1000;
|
2008-04-17 16:25:29 +00:00
|
|
|
|
2018-11-22 01:09:40 +00:00
|
|
|
// Notify GAL
|
|
|
|
TOOL_MANAGER* mgr = GetToolManager();
|
|
|
|
|
|
|
|
if( mgr && IsGalCanvasActive() )
|
|
|
|
mgr->RunAction( "common.Control.gridPreset", true, idx );
|
|
|
|
else
|
|
|
|
SetPresetGrid( idx );
|
2013-06-24 12:33:02 +00:00
|
|
|
|
2013-09-20 15:29:32 +00:00
|
|
|
m_canvas->Refresh();
|
2007-05-06 16:03:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::OnSelectZoom( wxCommandEvent& event )
|
2007-08-15 02:43:57 +00:00
|
|
|
{
|
2011-12-14 20:03:15 +00:00
|
|
|
if( m_zoomSelectBox == NULL )
|
2009-11-23 15:16:50 +00:00
|
|
|
return; // Should not happen!
|
2007-08-15 02:43:57 +00:00
|
|
|
|
2011-12-14 20:03:15 +00:00
|
|
|
int id = m_zoomSelectBox->GetCurrentSelection();
|
2007-08-15 02:43:57 +00:00
|
|
|
|
2011-12-14 20:03:15 +00:00
|
|
|
if( id < 0 || !( id < (int)m_zoomSelectBox->GetCount() ) )
|
2009-01-29 14:26:20 +00:00
|
|
|
return;
|
2007-08-15 02:43:57 +00:00
|
|
|
|
2018-08-08 23:44:45 +00:00
|
|
|
if( IsGalCanvasActive() )
|
|
|
|
{
|
|
|
|
m_toolManager->RunAction( "common.Control.zoomPreset", true, id );
|
|
|
|
UpdateStatusBar();
|
|
|
|
m_galCanvas->Refresh();
|
|
|
|
}
|
|
|
|
else if( id == 0 ) // Auto zoom (Fit in Page)
|
2007-08-15 02:43:57 +00:00
|
|
|
{
|
2009-01-29 14:26:20 +00:00
|
|
|
Zoom_Automatique( true );
|
2018-08-08 23:44:45 +00:00
|
|
|
m_canvas->Refresh();
|
2007-08-15 02:43:57 +00:00
|
|
|
}
|
2009-01-29 14:26:20 +00:00
|
|
|
else
|
2007-08-15 02:43:57 +00:00
|
|
|
{
|
2018-05-25 11:59:57 +00:00
|
|
|
double selectedZoom = GetScreen()->m_ZoomList[id-1];
|
2011-01-31 18:26:12 +00:00
|
|
|
|
2018-08-08 23:44:45 +00:00
|
|
|
if( GetScreen()->SetZoom( selectedZoom ) )
|
|
|
|
RedrawScreen( GetScrollCenterPosition(), false );
|
2015-07-03 18:58:12 +00:00
|
|
|
}
|
2007-05-06 16:03:28 +00:00
|
|
|
}
|
|
|
|
|
2009-11-23 15:16:50 +00:00
|
|
|
|
2012-05-08 21:09:18 +00:00
|
|
|
double EDA_DRAW_FRAME::GetZoom()
|
2007-10-26 06:08:19 +00:00
|
|
|
{
|
2011-02-05 02:21:11 +00:00
|
|
|
return GetScreen()->GetZoom();
|
2007-10-26 06:08:19 +00:00
|
|
|
}
|
|
|
|
|
2007-08-15 02:43:57 +00:00
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::OnMouseEvent( wxMouseEvent& event )
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
2007-08-15 02:43:57 +00:00
|
|
|
event.Skip();
|
2007-05-06 16:03:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::OnLeftDClick( wxDC* DC, const wxPoint& MousePos )
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2007-08-15 02:43:57 +00:00
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::DisplayToolMsg( const wxString& msg )
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
2019-10-10 08:07:15 +00:00
|
|
|
SetStatusText( msg, 6 );
|
2007-05-06 16:03:28 +00:00
|
|
|
}
|
|
|
|
|
2007-08-15 02:43:57 +00:00
|
|
|
|
2019-06-10 14:16:14 +00:00
|
|
|
/*
|
|
|
|
* Display the grid status.
|
|
|
|
*/
|
|
|
|
void EDA_DRAW_FRAME::DisplayGridMsg()
|
|
|
|
{
|
|
|
|
wxString line;
|
|
|
|
wxString gridformatter;
|
|
|
|
|
|
|
|
switch( m_UserUnits )
|
|
|
|
{
|
|
|
|
case INCHES:
|
|
|
|
gridformatter = "grid %.3f";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MILLIMETRES:
|
|
|
|
gridformatter = "grid %.4f";
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
gridformatter = "grid %f";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
wxRealPoint curr_grid_size = GetScreen()->GetGridSize();
|
|
|
|
double grid = To_User_Unit( m_UserUnits, curr_grid_size.x );
|
|
|
|
line.Printf( gridformatter, grid );
|
|
|
|
|
|
|
|
SetStatusText( line, 4 );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::DisplayUnitsMsg()
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
2007-08-15 02:43:57 +00:00
|
|
|
wxString msg;
|
|
|
|
|
2018-02-02 15:44:53 +00:00
|
|
|
switch( m_UserUnits )
|
2007-08-15 02:43:57 +00:00
|
|
|
{
|
|
|
|
case INCHES:
|
2010-07-12 14:07:09 +00:00
|
|
|
msg = _( "Inches" );
|
2007-08-15 02:43:57 +00:00
|
|
|
break;
|
2007-05-06 16:03:28 +00:00
|
|
|
|
2010-07-12 14:07:09 +00:00
|
|
|
case MILLIMETRES:
|
2012-05-19 19:04:03 +00:00
|
|
|
msg = _( "mm" );
|
2007-08-15 02:43:57 +00:00
|
|
|
break;
|
2007-05-06 16:03:28 +00:00
|
|
|
|
2007-08-15 02:43:57 +00:00
|
|
|
default:
|
2012-05-19 19:04:03 +00:00
|
|
|
msg = _( "Units" );
|
2007-08-15 02:43:57 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2019-06-10 14:16:14 +00:00
|
|
|
SetStatusText( msg, 5 );
|
2007-05-06 16:03:28 +00:00
|
|
|
}
|
|
|
|
|
2007-08-15 02:43:57 +00:00
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::OnSize( wxSizeEvent& SizeEv )
|
2007-08-15 02:43:57 +00:00
|
|
|
{
|
2010-01-14 20:20:59 +00:00
|
|
|
m_FrameSize = GetClientSize( );
|
2007-08-15 02:43:57 +00:00
|
|
|
|
|
|
|
SizeEv.Skip();
|
2007-05-06 16:03:28 +00:00
|
|
|
}
|
|
|
|
|
2007-08-15 02:43:57 +00:00
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::SetToolID( int aId, int aCursor, const wxString& aToolMsg )
|
2007-08-15 02:43:57 +00:00
|
|
|
{
|
2010-07-27 09:01:26 +00:00
|
|
|
// Keep default cursor in toolbars
|
|
|
|
SetCursor( wxNullCursor );
|
2011-01-31 18:26:12 +00:00
|
|
|
|
2011-12-22 13:28:11 +00:00
|
|
|
// Change m_canvas cursor if requested.
|
|
|
|
if( m_canvas && aCursor >= 0 )
|
|
|
|
m_canvas->SetCurrentCursor( aCursor );
|
2011-01-31 18:26:12 +00:00
|
|
|
|
2017-06-12 13:10:43 +00:00
|
|
|
// Change GAL canvas cursor if requested.
|
|
|
|
if( IsGalCanvasActive() && aCursor >= 0 )
|
|
|
|
GetGalCanvas()->SetCurrentCursor( aCursor );
|
|
|
|
|
2010-07-27 16:49:38 +00:00
|
|
|
DisplayToolMsg( aToolMsg );
|
2007-08-15 02:43:57 +00:00
|
|
|
|
2010-07-27 16:49:38 +00:00
|
|
|
if( aId < 0 )
|
2007-08-15 02:43:57 +00:00
|
|
|
return;
|
|
|
|
|
2011-02-24 20:22:12 +00:00
|
|
|
wxCHECK2_MSG( aId >= ID_NO_TOOL_SELECTED, aId = ID_NO_TOOL_SELECTED,
|
|
|
|
wxString::Format( wxT( "Current tool ID cannot be set to %d." ), aId ) );
|
|
|
|
|
|
|
|
m_toolId = aId;
|
2007-05-06 16:03:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-06-12 13:10:43 +00:00
|
|
|
void EDA_DRAW_FRAME::SetNoToolSelected()
|
|
|
|
{
|
|
|
|
// Select the ID_NO_TOOL_SELECTED id tool (Idle tool)
|
|
|
|
|
|
|
|
int defaultCursor = wxCURSOR_DEFAULT;
|
|
|
|
|
|
|
|
// Change GAL canvas cursor if requested.
|
|
|
|
if( IsGalCanvasActive() )
|
|
|
|
defaultCursor = GetGalCanvas()->GetDefaultCursor();
|
|
|
|
else if( m_canvas )
|
|
|
|
defaultCursor = m_canvas->GetDefaultCursor();
|
|
|
|
|
|
|
|
SetToolID( ID_NO_TOOL_SELECTED, defaultCursor, wxEmptyString );
|
|
|
|
}
|
|
|
|
|
2018-11-09 13:32:13 +00:00
|
|
|
|
2012-09-02 12:06:47 +00:00
|
|
|
wxPoint EDA_DRAW_FRAME::GetGridPosition( const wxPoint& aPosition ) const
|
2011-02-03 19:27:28 +00:00
|
|
|
{
|
|
|
|
wxPoint pos = aPosition;
|
|
|
|
|
2011-02-05 02:21:11 +00:00
|
|
|
if( m_currentScreen != NULL && m_snapToGrid )
|
2013-08-03 05:15:23 +00:00
|
|
|
pos = GetNearestGridPosition( aPosition );
|
2011-02-03 19:27:28 +00:00
|
|
|
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-03-21 17:00:11 +00:00
|
|
|
void EDA_DRAW_FRAME::SetNextGrid()
|
|
|
|
{
|
2015-05-01 09:31:23 +00:00
|
|
|
BASE_SCREEN * screen = GetScreen();
|
|
|
|
|
2015-05-12 09:05:36 +00:00
|
|
|
int new_grid_cmd = screen->GetGridCmdId();
|
2015-05-01 09:31:23 +00:00
|
|
|
|
2015-05-12 09:05:36 +00:00
|
|
|
// if the grid id is the not the last, increment it
|
|
|
|
if( screen->GridExists( new_grid_cmd + 1 ) )
|
|
|
|
new_grid_cmd += 1;
|
2015-05-01 09:31:23 +00:00
|
|
|
|
2015-05-12 09:05:36 +00:00
|
|
|
SetPresetGrid( new_grid_cmd - ID_POPUP_GRID_LEVEL_1000 );
|
2014-03-21 17:00:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::SetPrevGrid()
|
|
|
|
{
|
2015-05-01 09:31:23 +00:00
|
|
|
BASE_SCREEN * screen = GetScreen();
|
2014-03-21 17:00:11 +00:00
|
|
|
|
2015-05-12 09:05:36 +00:00
|
|
|
int new_grid_cmd = screen->GetGridCmdId();
|
2015-04-30 08:46:04 +00:00
|
|
|
|
2015-05-12 09:05:36 +00:00
|
|
|
// if the grid id is the not the first, increment it
|
|
|
|
if( screen->GridExists( new_grid_cmd - 1 ) )
|
|
|
|
new_grid_cmd -= 1;
|
2015-05-01 09:31:23 +00:00
|
|
|
|
2015-05-12 09:05:36 +00:00
|
|
|
SetPresetGrid( new_grid_cmd - ID_POPUP_GRID_LEVEL_1000 );
|
2015-04-30 08:46:04 +00:00
|
|
|
}
|
2014-03-21 17:00:11 +00:00
|
|
|
|
|
|
|
|
2015-04-30 08:46:04 +00:00
|
|
|
void EDA_DRAW_FRAME::SetPresetGrid( int aIndex )
|
|
|
|
{
|
2015-05-12 09:05:36 +00:00
|
|
|
BASE_SCREEN * screen = GetScreen();
|
|
|
|
|
|
|
|
if( ! screen->GridExists( aIndex + ID_POPUP_GRID_LEVEL_1000 ) )
|
|
|
|
aIndex = screen->GetGrids()[0].m_CmdId;
|
|
|
|
|
|
|
|
// aIndex is a Command Id relative to ID_POPUP_GRID_LEVEL_1000 comand id code.
|
|
|
|
// we need an index in grid list (the cmd id in list is is screen->GetGrids()[0].m_CmdId):
|
|
|
|
int glistIdx = aIndex + ID_POPUP_GRID_LEVEL_1000 - screen->GetGrids()[0].m_CmdId;
|
|
|
|
|
2015-05-01 09:31:23 +00:00
|
|
|
if( m_gridSelectBox )
|
2015-04-30 08:46:04 +00:00
|
|
|
{
|
2019-05-25 21:14:20 +00:00
|
|
|
int highestGrid = ( int )m_gridSelectBox->GetCount();
|
|
|
|
|
|
|
|
// GerbView does not support the user grid setting
|
|
|
|
if( m_Ident != FRAME_GERBER )
|
|
|
|
highestGrid -= 2;
|
|
|
|
|
|
|
|
if( glistIdx < 0 || glistIdx >= highestGrid )
|
2015-05-01 09:31:23 +00:00
|
|
|
{
|
|
|
|
wxASSERT_MSG( false, "Invalid grid index" );
|
|
|
|
return;
|
|
|
|
}
|
2015-04-30 08:46:04 +00:00
|
|
|
|
2015-05-12 09:05:36 +00:00
|
|
|
m_gridSelectBox->SetSelection( glistIdx );
|
2015-05-01 09:31:23 +00:00
|
|
|
}
|
2015-04-30 08:46:04 +00:00
|
|
|
|
|
|
|
// Be sure m_LastGridSizeId is up to date.
|
|
|
|
m_LastGridSizeId = aIndex;
|
|
|
|
GetScreen()->SetGrid( aIndex + ID_POPUP_GRID_LEVEL_1000 );
|
2015-05-12 09:05:36 +00:00
|
|
|
|
|
|
|
// Put cursor on new grid
|
2015-04-30 08:46:04 +00:00
|
|
|
SetCrossHairPosition( RefPos( true ) );
|
2014-03-21 17:00:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-01-20 12:11:17 +00:00
|
|
|
int EDA_DRAW_FRAME::BlockCommand( EDA_KEY key )
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
2007-08-15 02:43:57 +00:00
|
|
|
return 0;
|
2007-05-06 16:03:28 +00:00
|
|
|
}
|
|
|
|
|
2007-08-15 02:43:57 +00:00
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::InitBlockPasteInfos()
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
2011-02-05 02:21:11 +00:00
|
|
|
GetScreen()->m_BlockLocate.ClearItemsList();
|
2011-12-29 20:11:42 +00:00
|
|
|
m_canvas->SetMouseCaptureCallback( NULL );
|
2007-05-06 16:03:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::HandleBlockPlace( wxDC* DC )
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
bool EDA_DRAW_FRAME::HandleBlockEnd( wxDC* DC )
|
2007-08-15 02:43:57 +00:00
|
|
|
{
|
2010-11-13 11:02:24 +00:00
|
|
|
return false;
|
2007-08-15 02:43:57 +00:00
|
|
|
}
|
2007-05-06 16:03:28 +00:00
|
|
|
|
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::UpdateStatusBar()
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
2015-01-06 07:38:58 +00:00
|
|
|
SetStatusText( GetZoomLevelIndicator(), 1 );
|
2007-05-06 16:03:28 +00:00
|
|
|
|
2012-04-13 18:51:24 +00:00
|
|
|
// Absolute and relative cursor positions are handled by overloading this function and
|
|
|
|
// handling the internal to user units conversion at the appropriate level.
|
2012-02-17 19:43:43 +00:00
|
|
|
|
|
|
|
// refresh units display
|
|
|
|
DisplayUnitsMsg();
|
2007-05-06 16:03:28 +00:00
|
|
|
}
|
2009-04-05 20:49:15 +00:00
|
|
|
|
2018-11-09 13:32:13 +00:00
|
|
|
|
2015-01-06 07:38:58 +00:00
|
|
|
const wxString EDA_DRAW_FRAME::GetZoomLevelIndicator() const
|
|
|
|
{
|
|
|
|
wxString Line;
|
2015-07-03 18:58:12 +00:00
|
|
|
double level = 0.0;
|
2015-01-06 07:38:58 +00:00
|
|
|
|
2015-07-03 18:58:12 +00:00
|
|
|
if( IsGalCanvasActive() )
|
2015-01-06 07:38:58 +00:00
|
|
|
{
|
2018-10-21 22:16:15 +00:00
|
|
|
level = m_galCanvas->GetGAL()->GetZoomFactor();
|
2015-01-06 07:38:58 +00:00
|
|
|
}
|
2015-07-03 18:58:12 +00:00
|
|
|
else if( BASE_SCREEN* screen = GetScreen() )
|
|
|
|
{
|
|
|
|
level = m_zoomLevelCoeff / (double) screen->GetZoom();
|
|
|
|
}
|
|
|
|
|
|
|
|
// returns a human readable value which can be displayed as zoom
|
|
|
|
// level indicator in dialogs.
|
|
|
|
Line.Printf( wxT( "Z %.2f" ), level );
|
2015-01-06 07:38:58 +00:00
|
|
|
|
|
|
|
return Line;
|
|
|
|
}
|
|
|
|
|
2011-02-11 20:48:13 +00:00
|
|
|
|
* KIWAY Milestone A): Make major modules into DLL/DSOs.
! The initial testing of this commit should be done using a Debug build so that
all the wxASSERT()s are enabled. Also, be sure and keep enabled the
USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it
off is senseless anyways. If you want stable code, go back to a prior version,
the one tagged with "stable".
* Relocate all functionality out of the wxApp derivative into more finely
targeted purposes:
a) DLL/DSO specific
b) PROJECT specific
c) EXE or process specific
d) configuration file specific data
e) configuration file manipulations functions.
All of this functionality was blended into an extremely large wxApp derivative
and that was incompatible with the desire to support multiple concurrently
loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects.
An amazing amount of organization come from simply sorting each bit of
functionality into the proper box.
* Switch to wxConfigBase from wxConfig everywhere except instantiation.
* Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD,
PGM_SINGLE_TOP,
* Remove "Return" prefix on many function names.
* Remove obvious comments from CMakeLists.txt files, and from else() and endif()s.
* Fix building boost for use in a DSO on linux.
* Remove some of the assumptions in the CMakeLists.txt files that windows had
to be the host platform when building windows binaries.
* Reduce the number of wxStrings being constructed at program load time via
static construction.
* Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that
these functions are useful even when the wxConfigBase comes from another
source, as is the case in the KICAD_MANAGER_FRAME.
* Move the setting of the KIPRJMOD environment variable into class PROJECT,
so that it can be moved into a project variable soon, and out of FP_LIB_TABLE.
* Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all
its child wxFrames and wxDialogs now have a Kiway() member function which
returns a KIWAY& that that window tree branch is in support of. This is like
wxWindows DNA in that child windows get this member with proper value at time
of construction.
* Anticipate some of the needs for milestones B) and C) and make code
adjustments now in an effort to reduce work in those milestones.
* No testing has been done for python scripting, since milestone C) has that
being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
|
|
|
void EDA_DRAW_FRAME::LoadSettings( wxConfigBase* aCfg )
|
2009-04-05 20:49:15 +00:00
|
|
|
{
|
* KIWAY Milestone A): Make major modules into DLL/DSOs.
! The initial testing of this commit should be done using a Debug build so that
all the wxASSERT()s are enabled. Also, be sure and keep enabled the
USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it
off is senseless anyways. If you want stable code, go back to a prior version,
the one tagged with "stable".
* Relocate all functionality out of the wxApp derivative into more finely
targeted purposes:
a) DLL/DSO specific
b) PROJECT specific
c) EXE or process specific
d) configuration file specific data
e) configuration file manipulations functions.
All of this functionality was blended into an extremely large wxApp derivative
and that was incompatible with the desire to support multiple concurrently
loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects.
An amazing amount of organization come from simply sorting each bit of
functionality into the proper box.
* Switch to wxConfigBase from wxConfig everywhere except instantiation.
* Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD,
PGM_SINGLE_TOP,
* Remove "Return" prefix on many function names.
* Remove obvious comments from CMakeLists.txt files, and from else() and endif()s.
* Fix building boost for use in a DSO on linux.
* Remove some of the assumptions in the CMakeLists.txt files that windows had
to be the host platform when building windows binaries.
* Reduce the number of wxStrings being constructed at program load time via
static construction.
* Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that
these functions are useful even when the wxConfigBase comes from another
source, as is the case in the KICAD_MANAGER_FRAME.
* Move the setting of the KIPRJMOD environment variable into class PROJECT,
so that it can be moved into a project variable soon, and out of FP_LIB_TABLE.
* Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all
its child wxFrames and wxDialogs now have a Kiway() member function which
returns a KIWAY& that that window tree branch is in support of. This is like
wxWindows DNA in that child windows get this member with proper value at time
of construction.
* Anticipate some of the needs for milestones B) and C) and make code
adjustments now in an effort to reduce work in those milestones.
* No testing has been done for python scripting, since milestone C) has that
being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
|
|
|
EDA_BASE_FRAME::LoadSettings( aCfg );
|
2009-04-05 20:49:15 +00:00
|
|
|
|
2015-08-31 06:43:33 +00:00
|
|
|
wxString baseCfgName = ConfigBaseName();
|
2018-09-04 00:00:17 +00:00
|
|
|
wxConfigBase* cmnCfg = Pgm().CommonSettings();
|
2015-03-03 14:53:47 +00:00
|
|
|
|
2018-02-02 15:44:53 +00:00
|
|
|
// Read units used in dialogs and toolbars
|
|
|
|
EDA_UNITS_T unitsTmp;
|
|
|
|
|
|
|
|
if( aCfg->Read( baseCfgName + UserUnitsEntryKeyword, (int*) &unitsTmp ) )
|
|
|
|
SetUserUnits( unitsTmp );
|
|
|
|
else
|
|
|
|
SetUserUnits( MILLIMETRES );
|
|
|
|
|
|
|
|
// Read show/hide grid entry
|
2010-02-01 21:23:27 +00:00
|
|
|
bool btmp;
|
2015-03-03 14:53:47 +00:00
|
|
|
if( aCfg->Read( baseCfgName + ShowGridEntryKeyword, &btmp ) )
|
2011-02-09 19:47:33 +00:00
|
|
|
SetGridVisibility( btmp );
|
2011-01-31 18:26:12 +00:00
|
|
|
|
2017-04-01 09:48:02 +00:00
|
|
|
// Read grid color:
|
|
|
|
COLOR4D wtmp = COLOR4D::UNSPECIFIED;
|
|
|
|
|
2018-09-25 19:23:54 +00:00
|
|
|
if( wtmp.SetFromWxString( aCfg->Read( baseCfgName + GridColorEntryKeyword, wxT( "NONE" ) ) ) )
|
2017-04-01 09:48:02 +00:00
|
|
|
SetGridColor( wtmp );
|
2011-01-31 18:26:12 +00:00
|
|
|
|
2015-03-03 14:53:47 +00:00
|
|
|
aCfg->Read( baseCfgName + LastGridSizeIdKeyword, &m_LastGridSizeId, 0L );
|
2014-02-02 19:51:50 +00:00
|
|
|
|
|
|
|
// m_LastGridSizeId is an offset, expected to be >= 0
|
|
|
|
if( m_LastGridSizeId < 0 )
|
|
|
|
m_LastGridSizeId = 0;
|
2015-08-05 14:28:27 +00:00
|
|
|
|
2015-08-06 00:10:52 +00:00
|
|
|
m_UndoRedoCountMax = aCfg->Read( baseCfgName + MaxUndoItemsEntry,
|
|
|
|
long( DEFAULT_MAX_UNDO_ITEMS ) );
|
2016-12-23 15:21:00 +00:00
|
|
|
|
2018-01-04 14:28:02 +00:00
|
|
|
aCfg->Read( baseCfgName + FirstRunShownKeyword, &m_firstRunDialogSetting, 0L );
|
|
|
|
|
2019-04-11 19:35:52 +00:00
|
|
|
m_galDisplayOptions.ReadConfig( *cmnCfg, *aCfg, baseCfgName, this );
|
2009-04-05 20:49:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
* KIWAY Milestone A): Make major modules into DLL/DSOs.
! The initial testing of this commit should be done using a Debug build so that
all the wxASSERT()s are enabled. Also, be sure and keep enabled the
USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it
off is senseless anyways. If you want stable code, go back to a prior version,
the one tagged with "stable".
* Relocate all functionality out of the wxApp derivative into more finely
targeted purposes:
a) DLL/DSO specific
b) PROJECT specific
c) EXE or process specific
d) configuration file specific data
e) configuration file manipulations functions.
All of this functionality was blended into an extremely large wxApp derivative
and that was incompatible with the desire to support multiple concurrently
loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects.
An amazing amount of organization come from simply sorting each bit of
functionality into the proper box.
* Switch to wxConfigBase from wxConfig everywhere except instantiation.
* Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD,
PGM_SINGLE_TOP,
* Remove "Return" prefix on many function names.
* Remove obvious comments from CMakeLists.txt files, and from else() and endif()s.
* Fix building boost for use in a DSO on linux.
* Remove some of the assumptions in the CMakeLists.txt files that windows had
to be the host platform when building windows binaries.
* Reduce the number of wxStrings being constructed at program load time via
static construction.
* Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that
these functions are useful even when the wxConfigBase comes from another
source, as is the case in the KICAD_MANAGER_FRAME.
* Move the setting of the KIPRJMOD environment variable into class PROJECT,
so that it can be moved into a project variable soon, and out of FP_LIB_TABLE.
* Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all
its child wxFrames and wxDialogs now have a Kiway() member function which
returns a KIWAY& that that window tree branch is in support of. This is like
wxWindows DNA in that child windows get this member with proper value at time
of construction.
* Anticipate some of the needs for milestones B) and C) and make code
adjustments now in an effort to reduce work in those milestones.
* No testing has been done for python scripting, since milestone C) has that
being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
|
|
|
void EDA_DRAW_FRAME::SaveSettings( wxConfigBase* aCfg )
|
2009-04-05 20:49:15 +00:00
|
|
|
{
|
* KIWAY Milestone A): Make major modules into DLL/DSOs.
! The initial testing of this commit should be done using a Debug build so that
all the wxASSERT()s are enabled. Also, be sure and keep enabled the
USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it
off is senseless anyways. If you want stable code, go back to a prior version,
the one tagged with "stable".
* Relocate all functionality out of the wxApp derivative into more finely
targeted purposes:
a) DLL/DSO specific
b) PROJECT specific
c) EXE or process specific
d) configuration file specific data
e) configuration file manipulations functions.
All of this functionality was blended into an extremely large wxApp derivative
and that was incompatible with the desire to support multiple concurrently
loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects.
An amazing amount of organization come from simply sorting each bit of
functionality into the proper box.
* Switch to wxConfigBase from wxConfig everywhere except instantiation.
* Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD,
PGM_SINGLE_TOP,
* Remove "Return" prefix on many function names.
* Remove obvious comments from CMakeLists.txt files, and from else() and endif()s.
* Fix building boost for use in a DSO on linux.
* Remove some of the assumptions in the CMakeLists.txt files that windows had
to be the host platform when building windows binaries.
* Reduce the number of wxStrings being constructed at program load time via
static construction.
* Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that
these functions are useful even when the wxConfigBase comes from another
source, as is the case in the KICAD_MANAGER_FRAME.
* Move the setting of the KIPRJMOD environment variable into class PROJECT,
so that it can be moved into a project variable soon, and out of FP_LIB_TABLE.
* Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all
its child wxFrames and wxDialogs now have a Kiway() member function which
returns a KIWAY& that that window tree branch is in support of. This is like
wxWindows DNA in that child windows get this member with proper value at time
of construction.
* Anticipate some of the needs for milestones B) and C) and make code
adjustments now in an effort to reduce work in those milestones.
* No testing has been done for python scripting, since milestone C) has that
being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
|
|
|
EDA_BASE_FRAME::SaveSettings( aCfg );
|
2009-04-05 20:49:15 +00:00
|
|
|
|
2015-08-31 06:43:33 +00:00
|
|
|
wxString baseCfgName = ConfigBaseName();
|
2015-03-03 14:53:47 +00:00
|
|
|
|
2018-02-02 15:44:53 +00:00
|
|
|
aCfg->Write( baseCfgName + UserUnitsEntryKeyword, (int) m_UserUnits );
|
2015-03-03 14:53:47 +00:00
|
|
|
aCfg->Write( baseCfgName + ShowGridEntryKeyword, IsGridVisible() );
|
2017-02-20 16:57:41 +00:00
|
|
|
aCfg->Write( baseCfgName + GridColorEntryKeyword,
|
|
|
|
GetGridColor().ToColour().GetAsString( wxC2S_CSS_SYNTAX ) );
|
2015-03-03 14:53:47 +00:00
|
|
|
aCfg->Write( baseCfgName + LastGridSizeIdKeyword, ( long ) m_LastGridSizeId );
|
2018-01-04 14:28:02 +00:00
|
|
|
aCfg->Write( baseCfgName + FirstRunShownKeyword, m_firstRunDialogSetting );
|
2016-04-08 12:11:05 +00:00
|
|
|
|
|
|
|
if( GetScreen() )
|
|
|
|
aCfg->Write( baseCfgName + MaxUndoItemsEntry, long( GetScreen()->GetMaxUndoItems() ) );
|
2018-09-04 00:00:17 +00:00
|
|
|
|
2019-04-11 19:35:52 +00:00
|
|
|
m_galDisplayOptions.WriteConfig( *aCfg, baseCfgName );
|
2009-10-14 19:43:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-21 19:30:59 +00:00
|
|
|
void EDA_DRAW_FRAME::AppendMsgPanel( const wxString& textUpper,
|
|
|
|
const wxString& textLower,
|
2017-02-20 16:57:41 +00:00
|
|
|
COLOR4D color, int pad )
|
2009-10-14 19:43:31 +00:00
|
|
|
{
|
2011-12-12 14:02:37 +00:00
|
|
|
if( m_messagePanel == NULL )
|
2009-10-14 19:43:31 +00:00
|
|
|
return;
|
|
|
|
|
2011-12-12 14:02:37 +00:00
|
|
|
m_messagePanel->AppendMessage( textUpper, textLower, color, pad );
|
2009-10-14 19:43:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
Modular KiCad Blueprint Milestone B), major portions:
*) When kicad.exe closes a project, close any open KIFACEs so that they cannot
get disassociated from their true PROJECT.
*) Allow loading eeschema library editor from kicad.exe
*) Allow loading pcbnew library editor from kicad.exe
*) Rename LIB_COMPONENT to LIB_PART.
*) Add class PART_LIBS, and PART_LIB.
*) Make PART_LIBS non-global, i.e. PROJECT specific.
*) Implement "data on demand" for PART_LIBS
*) Implement "data on demand" for schematic SEARCH_STACK.
*) Use RSTRINGs to retain eeschema editor's notion of last library and part being edited.
*) Get rid of library search on every SCH_COMPONENT::Draw() call, instead use
a weak pointer.
*) Remove all chdir() calls so projects don't need to be CWD.
*) Romove APPEND support from OpenProjectFiles().
*) Make OpenProjectFiles() robust, even for creating new projects.
*) Load EESCHEMA colors in the KIWAY::OnKiwayStart() rather in window open,
and save them in the .eeschema config file, not in the project file.
*) Fix bug with wxDir() while accessing protected dirs in kicad.exe
*) Consolidate template copying into PROJECT class, not in kicad.exe source.
*) Generally untangle eeschema, making its libraries not global but rather
held in the PROJECT.
2014-08-13 20:28:54 +00:00
|
|
|
void EDA_DRAW_FRAME::ClearMsgPanel()
|
2009-10-14 19:43:31 +00:00
|
|
|
{
|
2011-12-12 14:02:37 +00:00
|
|
|
if( m_messagePanel == NULL )
|
2009-10-14 19:43:31 +00:00
|
|
|
return;
|
|
|
|
|
2011-12-12 14:02:37 +00:00
|
|
|
m_messagePanel->EraseMsgBox();
|
2009-04-05 20:49:15 +00:00
|
|
|
}
|
2011-03-11 15:53:28 +00:00
|
|
|
|
|
|
|
|
2013-01-12 17:32:24 +00:00
|
|
|
void EDA_DRAW_FRAME::SetMsgPanel( const MSG_PANEL_ITEMS& aList )
|
|
|
|
{
|
2013-12-29 11:01:54 +00:00
|
|
|
if( m_messagePanel == NULL )
|
2013-01-12 17:32:24 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
ClearMsgPanel();
|
|
|
|
|
|
|
|
for( unsigned i = 0; i < aList.size(); i++ )
|
|
|
|
m_messagePanel->AppendMessage( aList[i] );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::SetMsgPanel( EDA_ITEM* aItem )
|
|
|
|
{
|
|
|
|
wxCHECK_RET( aItem != NULL, wxT( "Invalid EDA_ITEM pointer. Bad programmer." ) );
|
|
|
|
|
|
|
|
MSG_PANEL_ITEMS items;
|
2018-04-10 10:52:12 +00:00
|
|
|
aItem->GetMsgPanelInfo( m_UserUnits, items );
|
2013-01-12 17:32:24 +00:00
|
|
|
SetMsgPanel( items );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-07-03 18:58:12 +00:00
|
|
|
void EDA_DRAW_FRAME::UpdateMsgPanel()
|
|
|
|
{
|
|
|
|
EDA_ITEM* item = GetScreen()->GetCurItem();
|
|
|
|
|
|
|
|
if( item )
|
|
|
|
SetMsgPanel( item );
|
|
|
|
}
|
|
|
|
|
2018-11-09 13:32:13 +00:00
|
|
|
|
2015-08-25 14:16:15 +00:00
|
|
|
// FIXME: There needs to be a better way for child windows to load preferences.
|
|
|
|
// This function pushes four preferences from a parent window to a child window
|
|
|
|
// i.e. from eeschema to the schematic symbol editor
|
|
|
|
void EDA_DRAW_FRAME::PushPreferences( const EDA_DRAW_PANEL* aParentCanvas )
|
|
|
|
{
|
|
|
|
m_canvas->SetEnableZoomNoCenter( aParentCanvas->GetEnableZoomNoCenter() );
|
|
|
|
m_canvas->SetEnableAutoPan( aParentCanvas->GetEnableAutoPan() );
|
|
|
|
}
|
2015-07-03 18:58:12 +00:00
|
|
|
|
2018-11-09 13:32:13 +00:00
|
|
|
|
2016-06-08 11:19:53 +00:00
|
|
|
bool EDA_DRAW_FRAME::HandleBlockBegin( wxDC* aDC, EDA_KEY aKey, const wxPoint& aPosition,
|
2018-11-09 13:32:13 +00:00
|
|
|
int aExplicitCommand )
|
2012-03-26 23:47:08 +00:00
|
|
|
{
|
2015-05-03 06:31:14 +00:00
|
|
|
BLOCK_SELECTOR* block = &GetScreen()->m_BlockLocate;
|
2012-03-26 23:47:08 +00:00
|
|
|
|
2015-05-03 06:31:14 +00:00
|
|
|
if( ( block->GetCommand() != BLOCK_IDLE ) || ( block->GetState() != STATE_NO_BLOCK ) )
|
2012-03-26 23:47:08 +00:00
|
|
|
return false;
|
|
|
|
|
2016-06-08 11:19:53 +00:00
|
|
|
if( aExplicitCommand == 0 )
|
|
|
|
block->SetCommand( (BLOCK_COMMAND_T) BlockCommand( aKey ) );
|
|
|
|
else
|
|
|
|
block->SetCommand( (BLOCK_COMMAND_T) aExplicitCommand );
|
2012-03-26 23:47:08 +00:00
|
|
|
|
2015-05-03 06:31:14 +00:00
|
|
|
if( block->GetCommand() == 0 )
|
2012-03-26 23:47:08 +00:00
|
|
|
return false;
|
|
|
|
|
2015-05-03 06:31:14 +00:00
|
|
|
switch( block->GetCommand() )
|
2012-03-26 23:47:08 +00:00
|
|
|
{
|
|
|
|
case BLOCK_IDLE:
|
|
|
|
break;
|
|
|
|
|
2014-07-29 16:38:27 +00:00
|
|
|
case BLOCK_MOVE: // Move
|
|
|
|
case BLOCK_DRAG: // Drag (block defined)
|
|
|
|
case BLOCK_DRAG_ITEM: // Drag from a drag item command
|
2017-07-04 08:08:33 +00:00
|
|
|
case BLOCK_DUPLICATE: // Duplicate
|
|
|
|
case BLOCK_DUPLICATE_AND_INCREMENT: // Duplicate and increment relevant references
|
2014-07-29 16:38:27 +00:00
|
|
|
case BLOCK_DELETE: // Delete
|
2017-07-04 08:08:33 +00:00
|
|
|
case BLOCK_COPY: // Copy
|
2014-07-29 16:38:27 +00:00
|
|
|
case BLOCK_FLIP: // Flip
|
|
|
|
case BLOCK_ZOOM: // Window Zoom
|
|
|
|
case BLOCK_PRESELECT_MOVE: // Move with preselection list
|
2015-05-03 06:31:14 +00:00
|
|
|
block->InitData( m_canvas, aPosition );
|
2012-03-26 23:47:08 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case BLOCK_PASTE:
|
2015-05-03 06:31:14 +00:00
|
|
|
block->InitData( m_canvas, aPosition );
|
|
|
|
block->SetLastCursorPosition( wxPoint( 0, 0 ) );
|
2012-03-26 23:47:08 +00:00
|
|
|
InitBlockPasteInfos();
|
|
|
|
|
2015-05-03 06:31:14 +00:00
|
|
|
if( block->GetCount() == 0 ) // No data to paste
|
2012-03-26 23:47:08 +00:00
|
|
|
{
|
2015-05-03 06:31:14 +00:00
|
|
|
DisplayError( this, wxT( "No block to paste" ), 20 );
|
2012-03-26 23:47:08 +00:00
|
|
|
GetScreen()->m_BlockLocate.SetCommand( BLOCK_IDLE );
|
|
|
|
m_canvas->SetMouseCaptureCallback( NULL );
|
2017-07-03 11:46:59 +00:00
|
|
|
block->SetState( STATE_NO_BLOCK );
|
|
|
|
block->SetMessageBlock( this );
|
2012-03-26 23:47:08 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( !m_canvas->IsMouseCaptured() )
|
|
|
|
{
|
2015-05-03 06:31:14 +00:00
|
|
|
block->ClearItemsList();
|
2012-03-26 23:47:08 +00:00
|
|
|
DisplayError( this,
|
|
|
|
wxT( "EDA_DRAW_FRAME::HandleBlockBegin() Err: m_mouseCaptureCallback NULL" ) );
|
2017-07-03 11:46:59 +00:00
|
|
|
block->SetState( STATE_NO_BLOCK );
|
|
|
|
block->SetMessageBlock( this );
|
2012-03-26 23:47:08 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-05-03 06:31:14 +00:00
|
|
|
block->SetState( STATE_BLOCK_MOVE );
|
2012-03-26 23:47:08 +00:00
|
|
|
m_canvas->CallMouseCapture( aDC, aPosition, false );
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2013-06-13 11:43:29 +00:00
|
|
|
{
|
|
|
|
wxString msg;
|
|
|
|
msg << wxT( "EDA_DRAW_FRAME::HandleBlockBegin() error: Unknown command " ) <<
|
2015-05-03 06:31:14 +00:00
|
|
|
block->GetCommand();
|
2013-06-13 11:43:29 +00:00
|
|
|
DisplayError( this, msg );
|
|
|
|
}
|
|
|
|
break;
|
2012-03-26 23:47:08 +00:00
|
|
|
}
|
|
|
|
|
2015-05-03 06:31:14 +00:00
|
|
|
block->SetMessageBlock( this );
|
2012-03-26 23:47:08 +00:00
|
|
|
return true;
|
|
|
|
}
|
2012-04-23 21:56:26 +00:00
|
|
|
|
|
|
|
|
2014-07-29 16:38:27 +00:00
|
|
|
// I am not seeing a problem with this size yet:
|
2012-05-06 23:32:01 +00:00
|
|
|
static const double MAX_AXIS = INT_MAX - 100;
|
2012-05-06 20:10:43 +00:00
|
|
|
|
|
|
|
#define VIRT_MIN (-MAX_AXIS/2.0) ///< min X or Y coordinate in virtual space
|
|
|
|
#define VIRT_MAX (MAX_AXIS/2.0) ///< max X or Y coordinate in virtual space
|
2012-05-05 04:55:36 +00:00
|
|
|
|
|
|
|
|
2012-04-23 21:56:26 +00:00
|
|
|
void EDA_DRAW_FRAME::AdjustScrollBars( const wxPoint& aCenterPositionIU )
|
|
|
|
{
|
|
|
|
BASE_SCREEN* screen = GetScreen();
|
|
|
|
|
2013-08-03 18:57:15 +00:00
|
|
|
if( !screen || !m_canvas )
|
2012-04-23 21:56:26 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
double scale = screen->GetScalingFactor();
|
|
|
|
|
2012-05-08 21:09:18 +00:00
|
|
|
wxLogTrace( traceScrollSettings, wxT( "Center Position = ( %d, %d ), scale = %.10g" ),
|
2012-04-23 21:56:26 +00:00
|
|
|
aCenterPositionIU.x, aCenterPositionIU.y, scale );
|
|
|
|
|
|
|
|
// Calculate the portion of the drawing that can be displayed in the
|
|
|
|
// client area at the current zoom level.
|
|
|
|
|
|
|
|
// visible viewport in device units ~ pixels
|
2012-04-24 02:39:56 +00:00
|
|
|
wxSize clientSizeDU = m_canvas->GetClientSize();
|
2012-04-23 21:56:26 +00:00
|
|
|
|
|
|
|
// Size of the client window in IU
|
2012-04-24 02:39:56 +00:00
|
|
|
DSIZE clientSizeIU( clientSizeDU.x / scale, clientSizeDU.y / scale );
|
2012-04-23 21:56:26 +00:00
|
|
|
|
|
|
|
// Full drawing or "page" rectangle in internal units
|
2013-03-28 16:30:09 +00:00
|
|
|
DBOX pageRectIU( wxPoint( 0, 0 ), wxSize( GetPageSizeIU().x, GetPageSizeIU().y ) );
|
2012-04-23 21:56:26 +00:00
|
|
|
|
2018-06-19 17:52:08 +00:00
|
|
|
// Remark: if something is modified here, perhaps EDA_DRAW_FRAME::RedrawScreen2()
|
|
|
|
// will need changes accordint to the way the center is computed
|
2016-06-08 00:28:11 +00:00
|
|
|
// Account for scrollbars
|
|
|
|
wxSize scrollbarSizeDU = m_canvas->GetSize() - m_canvas->GetClientSize();
|
2016-06-08 10:26:39 +00:00
|
|
|
wxSize scrollbarSizeIU = scrollbarSizeDU * (1 / scale);
|
2016-06-08 00:28:11 +00:00
|
|
|
wxPoint centerAdjustedIU = aCenterPositionIU + scrollbarSizeIU / 2;
|
|
|
|
|
2012-04-23 21:56:26 +00:00
|
|
|
// The upper left corner of the client rectangle in internal units.
|
2016-06-08 00:28:11 +00:00
|
|
|
double xIU = centerAdjustedIU.x - clientSizeIU.x / 2.0;
|
|
|
|
double yIU = centerAdjustedIU.y - clientSizeIU.y / 2.0;
|
2012-04-23 21:56:26 +00:00
|
|
|
|
|
|
|
// If drawn around the center, adjust the client rectangle accordingly.
|
|
|
|
if( screen->m_Center )
|
|
|
|
{
|
|
|
|
// half page offset.
|
2013-03-28 16:30:09 +00:00
|
|
|
xIU += pageRectIU.GetWidth() / 2.0;
|
|
|
|
yIU += pageRectIU.GetHeight() / 2.0;
|
2012-04-23 21:56:26 +00:00
|
|
|
}
|
|
|
|
|
2013-03-28 16:30:09 +00:00
|
|
|
DBOX clientRectIU( wxPoint( xIU, yIU ), wxSize( clientSizeIU.x, clientSizeIU.y ) );
|
2012-05-05 04:55:36 +00:00
|
|
|
wxPoint centerPositionIU;
|
|
|
|
|
|
|
|
// put "int" limits on the clientRect
|
2012-05-06 20:10:43 +00:00
|
|
|
if( clientRectIU.GetLeft() < VIRT_MIN )
|
|
|
|
clientRectIU.MoveLeftTo( VIRT_MIN );
|
|
|
|
if( clientRectIU.GetTop() < VIRT_MIN )
|
|
|
|
clientRectIU.MoveTopTo( VIRT_MIN );
|
|
|
|
if( clientRectIU.GetRight() > VIRT_MAX )
|
|
|
|
clientRectIU.MoveRightTo( VIRT_MAX );
|
|
|
|
if( clientRectIU.GetBottom() > VIRT_MAX )
|
|
|
|
clientRectIU.MoveBottomTo( VIRT_MAX );
|
|
|
|
|
2013-03-28 16:30:09 +00:00
|
|
|
centerPositionIU.x = KiROUND( clientRectIU.GetX() + clientRectIU.GetWidth() / 2 );
|
|
|
|
centerPositionIU.y = KiROUND( clientRectIU.GetY() + clientRectIU.GetHeight() / 2 );
|
2012-05-05 04:55:36 +00:00
|
|
|
|
2012-05-08 21:09:18 +00:00
|
|
|
if( screen->m_Center )
|
|
|
|
{
|
2013-03-28 16:30:09 +00:00
|
|
|
centerPositionIU.x -= KiROUND( pageRectIU.GetWidth() / 2.0 );
|
|
|
|
centerPositionIU.y -= KiROUND( pageRectIU.GetHeight() / 2.0 );
|
2012-05-08 21:09:18 +00:00
|
|
|
}
|
|
|
|
|
2012-04-24 02:39:56 +00:00
|
|
|
DSIZE virtualSizeIU;
|
2012-04-23 21:56:26 +00:00
|
|
|
|
|
|
|
if( pageRectIU.GetLeft() < clientRectIU.GetLeft() && pageRectIU.GetRight() > clientRectIU.GetRight() )
|
|
|
|
{
|
|
|
|
virtualSizeIU.x = pageRectIU.GetSize().x;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-03-28 16:30:09 +00:00
|
|
|
double pageCenterX = pageRectIU.GetX() + ( pageRectIU.GetWidth() / 2 );
|
|
|
|
double clientCenterX = clientRectIU.GetX() + ( clientRectIU.GetWidth() / 2 );
|
2012-04-23 21:56:26 +00:00
|
|
|
|
2013-03-28 16:30:09 +00:00
|
|
|
if( clientRectIU.GetWidth() > pageRectIU.GetWidth() )
|
2012-04-23 21:56:26 +00:00
|
|
|
{
|
2012-05-05 04:55:36 +00:00
|
|
|
if( pageCenterX > clientCenterX )
|
|
|
|
virtualSizeIU.x = ( pageCenterX - clientRectIU.GetLeft() ) * 2;
|
|
|
|
else if( pageCenterX < clientCenterX )
|
|
|
|
virtualSizeIU.x = ( clientRectIU.GetRight() - pageCenterX ) * 2;
|
2012-04-23 21:56:26 +00:00
|
|
|
else
|
2013-03-28 16:30:09 +00:00
|
|
|
virtualSizeIU.x = clientRectIU.GetWidth();
|
2012-04-23 21:56:26 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-05-05 04:55:36 +00:00
|
|
|
if( pageCenterX > clientCenterX )
|
2013-03-28 16:30:09 +00:00
|
|
|
virtualSizeIU.x = pageRectIU.GetWidth() + ( (pageRectIU.GetLeft() - clientRectIU.GetLeft() ) * 2 );
|
2012-05-05 04:55:36 +00:00
|
|
|
else if( pageCenterX < clientCenterX )
|
2013-03-28 16:30:09 +00:00
|
|
|
virtualSizeIU.x = pageRectIU.GetWidth() + ( (clientRectIU.GetRight() - pageRectIU.GetRight() ) * 2 );
|
2012-04-23 21:56:26 +00:00
|
|
|
else
|
2013-03-28 16:30:09 +00:00
|
|
|
virtualSizeIU.x = pageRectIU.GetWidth();
|
2012-04-23 21:56:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if( pageRectIU.GetTop() < clientRectIU.GetTop() && pageRectIU.GetBottom() > clientRectIU.GetBottom() )
|
|
|
|
{
|
|
|
|
virtualSizeIU.y = pageRectIU.GetSize().y;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-03-28 16:30:09 +00:00
|
|
|
double pageCenterY = pageRectIU.GetY() + ( pageRectIU.GetHeight() / 2 );
|
|
|
|
double clientCenterY = clientRectIU.GetY() + ( clientRectIU.GetHeight() / 2 );
|
2012-04-23 21:56:26 +00:00
|
|
|
|
2013-03-28 16:30:09 +00:00
|
|
|
if( clientRectIU.GetHeight() > pageRectIU.GetHeight() )
|
2012-04-23 21:56:26 +00:00
|
|
|
{
|
2012-05-05 04:55:36 +00:00
|
|
|
if( pageCenterY > clientCenterY )
|
|
|
|
virtualSizeIU.y = ( pageCenterY - clientRectIU.GetTop() ) * 2;
|
|
|
|
else if( pageCenterY < clientCenterY )
|
|
|
|
virtualSizeIU.y = ( clientRectIU.GetBottom() - pageCenterY ) * 2;
|
2012-04-23 21:56:26 +00:00
|
|
|
else
|
2013-03-28 16:30:09 +00:00
|
|
|
virtualSizeIU.y = clientRectIU.GetHeight();
|
2012-04-23 21:56:26 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-05-05 04:55:36 +00:00
|
|
|
if( pageCenterY > clientCenterY )
|
2013-03-28 16:30:09 +00:00
|
|
|
virtualSizeIU.y = pageRectIU.GetHeight() +
|
2012-04-23 21:56:26 +00:00
|
|
|
( ( pageRectIU.GetTop() - clientRectIU.GetTop() ) * 2 );
|
2012-05-05 04:55:36 +00:00
|
|
|
else if( pageCenterY < clientCenterY )
|
2013-03-28 16:30:09 +00:00
|
|
|
virtualSizeIU.y = pageRectIU.GetHeight() +
|
2012-04-23 21:56:26 +00:00
|
|
|
( ( clientRectIU.GetBottom() - pageRectIU.GetBottom() ) * 2 );
|
|
|
|
else
|
2013-03-28 16:30:09 +00:00
|
|
|
virtualSizeIU.y = pageRectIU.GetHeight();
|
2012-04-23 21:56:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-06 20:10:43 +00:00
|
|
|
// put "int" limits on the virtualSizeIU
|
|
|
|
virtualSizeIU.x = std::min( virtualSizeIU.x, MAX_AXIS );
|
|
|
|
virtualSizeIU.y = std::min( virtualSizeIU.y, MAX_AXIS );
|
|
|
|
|
2012-04-23 21:56:26 +00:00
|
|
|
if( screen->m_Center )
|
|
|
|
{
|
|
|
|
screen->m_DrawOrg.x = -KiROUND( virtualSizeIU.x / 2.0 );
|
|
|
|
screen->m_DrawOrg.y = -KiROUND( virtualSizeIU.y / 2.0 );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-03-28 16:30:09 +00:00
|
|
|
screen->m_DrawOrg.x = -KiROUND( ( virtualSizeIU.x - pageRectIU.GetWidth() ) / 2.0 );
|
|
|
|
screen->m_DrawOrg.y = -KiROUND( ( virtualSizeIU.y - pageRectIU.GetHeight() ) / 2.0 );
|
2012-04-23 21:56:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Always set scrollbar pixels per unit to 1 unless you want the zoom
|
|
|
|
* around cursor to jump around. This reported problem occurs when the
|
|
|
|
* zoom point is not on a pixel per unit increment. If you set the
|
|
|
|
* pixels per unit to 10, you have potential for the zoom point to
|
|
|
|
* jump around +/-5 pixels from the nearest grid point.
|
|
|
|
*/
|
|
|
|
screen->m_ScrollPixelsPerUnitX = screen->m_ScrollPixelsPerUnitY = 1;
|
|
|
|
|
|
|
|
// Number of scroll bar units for the given zoom level in device units.
|
|
|
|
double unitsX = virtualSizeIU.x * scale;
|
|
|
|
double unitsY = virtualSizeIU.y * scale;
|
|
|
|
|
2016-06-09 08:43:32 +00:00
|
|
|
// Store the requested center position for later use
|
|
|
|
SetScrollCenterPosition( aCenterPositionIU );
|
|
|
|
|
2012-04-23 21:56:26 +00:00
|
|
|
// Calculate the scroll bar position in internal units to place the
|
|
|
|
// center position at the center of client rectangle.
|
2013-03-28 16:30:09 +00:00
|
|
|
double posX = centerPositionIU.x - clientRectIU.GetWidth() / 2.0 - screen->m_DrawOrg.x;
|
|
|
|
double posY = centerPositionIU.y - clientRectIU.GetHeight() / 2.0 - screen->m_DrawOrg.y;
|
2012-04-23 21:56:26 +00:00
|
|
|
|
|
|
|
// Convert scroll bar position to device units.
|
|
|
|
posX = KiROUND( posX * scale );
|
|
|
|
posY = KiROUND( posY * scale );
|
|
|
|
|
|
|
|
if( posX < 0 )
|
|
|
|
{
|
2012-05-08 21:09:18 +00:00
|
|
|
wxLogTrace( traceScrollSettings, wxT( "Required scroll bar X position %.10g" ), posX );
|
2012-04-23 21:56:26 +00:00
|
|
|
posX = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( posX > unitsX )
|
|
|
|
{
|
2012-05-08 21:09:18 +00:00
|
|
|
wxLogTrace( traceScrollSettings, wxT( "Required scroll bar X position %.10g" ), posX );
|
2012-04-23 21:56:26 +00:00
|
|
|
posX = unitsX;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( posY < 0 )
|
|
|
|
{
|
2012-05-08 21:09:18 +00:00
|
|
|
wxLogTrace( traceScrollSettings, wxT( "Required scroll bar Y position %.10g" ), posY );
|
2012-04-23 21:56:26 +00:00
|
|
|
posY = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( posY > unitsY )
|
|
|
|
{
|
2012-05-08 21:09:18 +00:00
|
|
|
wxLogTrace( traceScrollSettings, wxT( "Required scroll bar Y position %.10g" ), posY );
|
2012-04-23 21:56:26 +00:00
|
|
|
posY = unitsY;
|
|
|
|
}
|
|
|
|
|
|
|
|
screen->m_ScrollbarPos = wxPoint( KiROUND( posX ), KiROUND( posY ) );
|
|
|
|
screen->m_ScrollbarNumber = wxSize( KiROUND( unitsX ), KiROUND( unitsY ) );
|
|
|
|
|
|
|
|
wxLogTrace( traceScrollSettings,
|
2012-05-08 21:09:18 +00:00
|
|
|
wxT( "Drawing = (%.10g, %.10g), Client = (%.10g, %.10g), Offset = (%d, %d), SetScrollbars(%d, %d, %d, %d, %d, %d)" ),
|
2012-04-23 21:56:26 +00:00
|
|
|
virtualSizeIU.x, virtualSizeIU.y, clientSizeIU.x, clientSizeIU.y,
|
|
|
|
screen->m_DrawOrg.x, screen->m_DrawOrg.y,
|
|
|
|
screen->m_ScrollPixelsPerUnitX, screen->m_ScrollPixelsPerUnitY,
|
|
|
|
screen->m_ScrollbarNumber.x, screen->m_ScrollbarNumber.y,
|
|
|
|
screen->m_ScrollbarPos.x, screen->m_ScrollbarPos.y );
|
|
|
|
|
|
|
|
bool noRefresh = true;
|
|
|
|
|
|
|
|
m_canvas->SetScrollbars( screen->m_ScrollPixelsPerUnitX,
|
|
|
|
screen->m_ScrollPixelsPerUnitY,
|
|
|
|
screen->m_ScrollbarNumber.x,
|
|
|
|
screen->m_ScrollbarNumber.y,
|
|
|
|
screen->m_ScrollbarPos.x,
|
|
|
|
screen->m_ScrollbarPos.y, noRefresh );
|
|
|
|
}
|
Introduction of Graphics Abstraction Layer based rendering for pcbnew.
New classes:
- VIEW - represents view that is seen by user, takes care of layer ordering & visibility and how it is displayed (which location, how much zoomed, etc.)
- VIEW_ITEM - Base class for every item that can be displayed on VIEW (the biggest change is that now it may be necessary to override ViewBBox & ViewGetLayers method for derived classes).
- EDA_DRAW_PANEL_GAL - Inherits after EDA_DRAW_PANEL, displays VIEW output, right now it is not editable (in opposite to usual EDA_DRAW_PANEL).
- GAL/OPENGL_GAL/CAIRO_GAL - Base Graphics Abstraction Layer class + two different flavours (Cairo is not fully supported yet), that offers methods to draw primitives using different libraries.
- WX_VIEW_CONTROLS - Controller for VIEW, handles user events, allows zooming, panning, etc.
- PAINTER/PCB_PAINTER - Classes that uses GAL interface to draw items (as you may have already guessed - PCB_PAINTER is a class for drawing PCB specific object, PAINTER is an abstract class). Its methods are invoked by VIEW, when an item has to be drawn. To display a new type of item - you need to implement draw(ITEM_TYPE*) method that draws it using GAL methods.
- STROKE_FONT - Implements stroke font drawing using GAL methods.
Most important changes to Kicad original code:
* EDA_ITEM now inherits from VIEW_ITEM, which is a base class for all drawable objects.
* EDA_DRAW_FRAME contains both usual EDA_DRAW_PANEL and new EDA_DRAW_PANEL_GAL, that can be switched anytime.
* There are some new layers for displaying multilayer pads, vias & pads holes (these are not shown yet on the right sidebar in pcbnew)
* Display order of layers is different than in previous versions (if you are curious - you may check m_galLayerOrder@pcbnew/basepcbframe.cpp). Preserving usual order would result in not very natural display, such as showing silkscreen texts on the bottom.
* Introduced new hotkey (Alt+F12) and new menu option (View->Switch canvas) for switching canvas during runtime.
* Some of classes (mostly derived from BOARD_ITEM) now includes ViewBBox & ViewGetLayers methods.
* Removed tools/class_painter.h, as now it is extended and included in source code.
Build changes:
* GAL-based rendering option is turned on by a new compilation CMake option KICAD_GAL.
* When compiling with CMake option KICAD_GAL=ON, GLEW and Cairo libraries are required.
* GAL-related code is compiled into a static library (common/libgal).
* Build with KICAD_GAL=OFF should not need any new libraries and should come out as a standard version of Kicad
Currently most of items in pcbnew can be displayed using OpenGL (to be done are DIMENSIONS and MARKERS).
More details about GAL can be found in: http://www.ohwr.org/attachments/1884/view-spec.pdf
2013-04-02 06:54:03 +00:00
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::UseGalCanvas( bool aEnable )
|
|
|
|
{
|
2013-12-26 22:36:43 +00:00
|
|
|
KIGFX::VIEW* view = GetGalCanvas()->GetView();
|
|
|
|
KIGFX::GAL* gal = GetGalCanvas()->GetGAL();
|
2013-04-30 15:55:24 +00:00
|
|
|
|
2013-04-15 15:57:03 +00:00
|
|
|
// Display the same view after canvas switching
|
2015-07-02 19:25:39 +00:00
|
|
|
if( aEnable )
|
Introduction of Graphics Abstraction Layer based rendering for pcbnew.
New classes:
- VIEW - represents view that is seen by user, takes care of layer ordering & visibility and how it is displayed (which location, how much zoomed, etc.)
- VIEW_ITEM - Base class for every item that can be displayed on VIEW (the biggest change is that now it may be necessary to override ViewBBox & ViewGetLayers method for derived classes).
- EDA_DRAW_PANEL_GAL - Inherits after EDA_DRAW_PANEL, displays VIEW output, right now it is not editable (in opposite to usual EDA_DRAW_PANEL).
- GAL/OPENGL_GAL/CAIRO_GAL - Base Graphics Abstraction Layer class + two different flavours (Cairo is not fully supported yet), that offers methods to draw primitives using different libraries.
- WX_VIEW_CONTROLS - Controller for VIEW, handles user events, allows zooming, panning, etc.
- PAINTER/PCB_PAINTER - Classes that uses GAL interface to draw items (as you may have already guessed - PCB_PAINTER is a class for drawing PCB specific object, PAINTER is an abstract class). Its methods are invoked by VIEW, when an item has to be drawn. To display a new type of item - you need to implement draw(ITEM_TYPE*) method that draws it using GAL methods.
- STROKE_FONT - Implements stroke font drawing using GAL methods.
Most important changes to Kicad original code:
* EDA_ITEM now inherits from VIEW_ITEM, which is a base class for all drawable objects.
* EDA_DRAW_FRAME contains both usual EDA_DRAW_PANEL and new EDA_DRAW_PANEL_GAL, that can be switched anytime.
* There are some new layers for displaying multilayer pads, vias & pads holes (these are not shown yet on the right sidebar in pcbnew)
* Display order of layers is different than in previous versions (if you are curious - you may check m_galLayerOrder@pcbnew/basepcbframe.cpp). Preserving usual order would result in not very natural display, such as showing silkscreen texts on the bottom.
* Introduced new hotkey (Alt+F12) and new menu option (View->Switch canvas) for switching canvas during runtime.
* Some of classes (mostly derived from BOARD_ITEM) now includes ViewBBox & ViewGetLayers methods.
* Removed tools/class_painter.h, as now it is extended and included in source code.
Build changes:
* GAL-based rendering option is turned on by a new compilation CMake option KICAD_GAL.
* When compiling with CMake option KICAD_GAL=ON, GLEW and Cairo libraries are required.
* GAL-related code is compiled into a static library (common/libgal).
* Build with KICAD_GAL=OFF should not need any new libraries and should come out as a standard version of Kicad
Currently most of items in pcbnew can be displayed using OpenGL (to be done are DIMENSIONS and MARKERS).
More details about GAL can be found in: http://www.ohwr.org/attachments/1884/view-spec.pdf
2013-04-02 06:54:03 +00:00
|
|
|
{
|
2015-08-21 08:33:36 +00:00
|
|
|
// Switch to GAL renderer from legacy
|
2015-07-02 19:25:39 +00:00
|
|
|
if( !m_galCanvasActive )
|
|
|
|
{
|
|
|
|
// Set up viewport
|
2018-10-21 22:16:15 +00:00
|
|
|
view->SetScale( GetZoomLevelCoeff() / m_canvas->GetZoom() );
|
|
|
|
view->SetCenter(VECTOR2D( m_canvas->GetScreenCenterLogicalPosition() ) );
|
2015-07-02 19:25:39 +00:00
|
|
|
}
|
2013-09-10 12:35:10 +00:00
|
|
|
|
|
|
|
// Set up grid settings
|
|
|
|
gal->SetGridVisibility( IsGridVisible() );
|
2015-07-03 18:58:12 +00:00
|
|
|
gal->SetGridSize( VECTOR2D( GetScreen()->GetGridSize() ) );
|
2013-08-05 12:46:05 +00:00
|
|
|
gal->SetGridOrigin( VECTOR2D( GetGridOrigin() ) );
|
2015-06-26 15:30:41 +00:00
|
|
|
|
2015-07-09 08:18:27 +00:00
|
|
|
// Transfer EDA_DRAW_PANEL settings
|
2018-10-21 22:16:15 +00:00
|
|
|
KIGFX::VIEW_CONTROLS* viewControls = GetGalCanvas()->GetViewControls();
|
|
|
|
viewControls->EnableCursorWarping( !m_canvas->GetEnableZoomNoCenter() );
|
|
|
|
viewControls->EnableMousewheelPan( m_canvas->GetEnableMousewheelPan() );
|
|
|
|
viewControls->EnableAutoPan( m_canvas->GetEnableAutoPan() );
|
Introduction of Graphics Abstraction Layer based rendering for pcbnew.
New classes:
- VIEW - represents view that is seen by user, takes care of layer ordering & visibility and how it is displayed (which location, how much zoomed, etc.)
- VIEW_ITEM - Base class for every item that can be displayed on VIEW (the biggest change is that now it may be necessary to override ViewBBox & ViewGetLayers method for derived classes).
- EDA_DRAW_PANEL_GAL - Inherits after EDA_DRAW_PANEL, displays VIEW output, right now it is not editable (in opposite to usual EDA_DRAW_PANEL).
- GAL/OPENGL_GAL/CAIRO_GAL - Base Graphics Abstraction Layer class + two different flavours (Cairo is not fully supported yet), that offers methods to draw primitives using different libraries.
- WX_VIEW_CONTROLS - Controller for VIEW, handles user events, allows zooming, panning, etc.
- PAINTER/PCB_PAINTER - Classes that uses GAL interface to draw items (as you may have already guessed - PCB_PAINTER is a class for drawing PCB specific object, PAINTER is an abstract class). Its methods are invoked by VIEW, when an item has to be drawn. To display a new type of item - you need to implement draw(ITEM_TYPE*) method that draws it using GAL methods.
- STROKE_FONT - Implements stroke font drawing using GAL methods.
Most important changes to Kicad original code:
* EDA_ITEM now inherits from VIEW_ITEM, which is a base class for all drawable objects.
* EDA_DRAW_FRAME contains both usual EDA_DRAW_PANEL and new EDA_DRAW_PANEL_GAL, that can be switched anytime.
* There are some new layers for displaying multilayer pads, vias & pads holes (these are not shown yet on the right sidebar in pcbnew)
* Display order of layers is different than in previous versions (if you are curious - you may check m_galLayerOrder@pcbnew/basepcbframe.cpp). Preserving usual order would result in not very natural display, such as showing silkscreen texts on the bottom.
* Introduced new hotkey (Alt+F12) and new menu option (View->Switch canvas) for switching canvas during runtime.
* Some of classes (mostly derived from BOARD_ITEM) now includes ViewBBox & ViewGetLayers methods.
* Removed tools/class_painter.h, as now it is extended and included in source code.
Build changes:
* GAL-based rendering option is turned on by a new compilation CMake option KICAD_GAL.
* When compiling with CMake option KICAD_GAL=ON, GLEW and Cairo libraries are required.
* GAL-related code is compiled into a static library (common/libgal).
* Build with KICAD_GAL=OFF should not need any new libraries and should come out as a standard version of Kicad
Currently most of items in pcbnew can be displayed using OpenGL (to be done are DIMENSIONS and MARKERS).
More details about GAL can be found in: http://www.ohwr.org/attachments/1884/view-spec.pdf
2013-04-02 06:54:03 +00:00
|
|
|
}
|
2015-07-02 19:25:39 +00:00
|
|
|
else if( m_galCanvasActive )
|
Introduction of Graphics Abstraction Layer based rendering for pcbnew.
New classes:
- VIEW - represents view that is seen by user, takes care of layer ordering & visibility and how it is displayed (which location, how much zoomed, etc.)
- VIEW_ITEM - Base class for every item that can be displayed on VIEW (the biggest change is that now it may be necessary to override ViewBBox & ViewGetLayers method for derived classes).
- EDA_DRAW_PANEL_GAL - Inherits after EDA_DRAW_PANEL, displays VIEW output, right now it is not editable (in opposite to usual EDA_DRAW_PANEL).
- GAL/OPENGL_GAL/CAIRO_GAL - Base Graphics Abstraction Layer class + two different flavours (Cairo is not fully supported yet), that offers methods to draw primitives using different libraries.
- WX_VIEW_CONTROLS - Controller for VIEW, handles user events, allows zooming, panning, etc.
- PAINTER/PCB_PAINTER - Classes that uses GAL interface to draw items (as you may have already guessed - PCB_PAINTER is a class for drawing PCB specific object, PAINTER is an abstract class). Its methods are invoked by VIEW, when an item has to be drawn. To display a new type of item - you need to implement draw(ITEM_TYPE*) method that draws it using GAL methods.
- STROKE_FONT - Implements stroke font drawing using GAL methods.
Most important changes to Kicad original code:
* EDA_ITEM now inherits from VIEW_ITEM, which is a base class for all drawable objects.
* EDA_DRAW_FRAME contains both usual EDA_DRAW_PANEL and new EDA_DRAW_PANEL_GAL, that can be switched anytime.
* There are some new layers for displaying multilayer pads, vias & pads holes (these are not shown yet on the right sidebar in pcbnew)
* Display order of layers is different than in previous versions (if you are curious - you may check m_galLayerOrder@pcbnew/basepcbframe.cpp). Preserving usual order would result in not very natural display, such as showing silkscreen texts on the bottom.
* Introduced new hotkey (Alt+F12) and new menu option (View->Switch canvas) for switching canvas during runtime.
* Some of classes (mostly derived from BOARD_ITEM) now includes ViewBBox & ViewGetLayers methods.
* Removed tools/class_painter.h, as now it is extended and included in source code.
Build changes:
* GAL-based rendering option is turned on by a new compilation CMake option KICAD_GAL.
* When compiling with CMake option KICAD_GAL=ON, GLEW and Cairo libraries are required.
* GAL-related code is compiled into a static library (common/libgal).
* Build with KICAD_GAL=OFF should not need any new libraries and should come out as a standard version of Kicad
Currently most of items in pcbnew can be displayed using OpenGL (to be done are DIMENSIONS and MARKERS).
More details about GAL can be found in: http://www.ohwr.org/attachments/1884/view-spec.pdf
2013-04-02 06:54:03 +00:00
|
|
|
{
|
2015-08-21 08:33:36 +00:00
|
|
|
// Switch to legacy renderer from GAL
|
2018-09-16 21:19:33 +00:00
|
|
|
m_canvas->SetZoom( GetGalCanvas()->GetLegacyZoom() );
|
2015-04-30 08:46:02 +00:00
|
|
|
VECTOR2D center = view->GetCenter();
|
|
|
|
AdjustScrollBars( wxPoint( center.x, center.y ) );
|
Introduction of Graphics Abstraction Layer based rendering for pcbnew.
New classes:
- VIEW - represents view that is seen by user, takes care of layer ordering & visibility and how it is displayed (which location, how much zoomed, etc.)
- VIEW_ITEM - Base class for every item that can be displayed on VIEW (the biggest change is that now it may be necessary to override ViewBBox & ViewGetLayers method for derived classes).
- EDA_DRAW_PANEL_GAL - Inherits after EDA_DRAW_PANEL, displays VIEW output, right now it is not editable (in opposite to usual EDA_DRAW_PANEL).
- GAL/OPENGL_GAL/CAIRO_GAL - Base Graphics Abstraction Layer class + two different flavours (Cairo is not fully supported yet), that offers methods to draw primitives using different libraries.
- WX_VIEW_CONTROLS - Controller for VIEW, handles user events, allows zooming, panning, etc.
- PAINTER/PCB_PAINTER - Classes that uses GAL interface to draw items (as you may have already guessed - PCB_PAINTER is a class for drawing PCB specific object, PAINTER is an abstract class). Its methods are invoked by VIEW, when an item has to be drawn. To display a new type of item - you need to implement draw(ITEM_TYPE*) method that draws it using GAL methods.
- STROKE_FONT - Implements stroke font drawing using GAL methods.
Most important changes to Kicad original code:
* EDA_ITEM now inherits from VIEW_ITEM, which is a base class for all drawable objects.
* EDA_DRAW_FRAME contains both usual EDA_DRAW_PANEL and new EDA_DRAW_PANEL_GAL, that can be switched anytime.
* There are some new layers for displaying multilayer pads, vias & pads holes (these are not shown yet on the right sidebar in pcbnew)
* Display order of layers is different than in previous versions (if you are curious - you may check m_galLayerOrder@pcbnew/basepcbframe.cpp). Preserving usual order would result in not very natural display, such as showing silkscreen texts on the bottom.
* Introduced new hotkey (Alt+F12) and new menu option (View->Switch canvas) for switching canvas during runtime.
* Some of classes (mostly derived from BOARD_ITEM) now includes ViewBBox & ViewGetLayers methods.
* Removed tools/class_painter.h, as now it is extended and included in source code.
Build changes:
* GAL-based rendering option is turned on by a new compilation CMake option KICAD_GAL.
* When compiling with CMake option KICAD_GAL=ON, GLEW and Cairo libraries are required.
* GAL-related code is compiled into a static library (common/libgal).
* Build with KICAD_GAL=OFF should not need any new libraries and should come out as a standard version of Kicad
Currently most of items in pcbnew can be displayed using OpenGL (to be done are DIMENSIONS and MARKERS).
More details about GAL can be found in: http://www.ohwr.org/attachments/1884/view-spec.pdf
2013-04-02 06:54:03 +00:00
|
|
|
}
|
|
|
|
|
2013-04-22 09:07:38 +00:00
|
|
|
m_canvas->SetEvtHandlerEnabled( !aEnable );
|
2013-12-26 22:36:43 +00:00
|
|
|
GetGalCanvas()->SetEvtHandlerEnabled( aEnable );
|
2013-04-22 09:07:38 +00:00
|
|
|
|
|
|
|
// Switch panes
|
2018-08-11 16:04:46 +00:00
|
|
|
m_auimgr.GetPane( "DrawFrame" ).Show( !aEnable );
|
|
|
|
m_auimgr.GetPane( "DrawFrameGal" ).Show( aEnable );
|
2013-04-22 09:07:38 +00:00
|
|
|
m_auimgr.Update();
|
|
|
|
|
2014-07-09 13:10:32 +00:00
|
|
|
// Reset current tool on switch();
|
2017-06-12 14:17:48 +00:00
|
|
|
SetNoToolSelected();
|
2014-07-09 13:10:32 +00:00
|
|
|
|
2014-07-09 08:34:00 +00:00
|
|
|
m_galCanvasActive = aEnable;
|
Introduction of Graphics Abstraction Layer based rendering for pcbnew.
New classes:
- VIEW - represents view that is seen by user, takes care of layer ordering & visibility and how it is displayed (which location, how much zoomed, etc.)
- VIEW_ITEM - Base class for every item that can be displayed on VIEW (the biggest change is that now it may be necessary to override ViewBBox & ViewGetLayers method for derived classes).
- EDA_DRAW_PANEL_GAL - Inherits after EDA_DRAW_PANEL, displays VIEW output, right now it is not editable (in opposite to usual EDA_DRAW_PANEL).
- GAL/OPENGL_GAL/CAIRO_GAL - Base Graphics Abstraction Layer class + two different flavours (Cairo is not fully supported yet), that offers methods to draw primitives using different libraries.
- WX_VIEW_CONTROLS - Controller for VIEW, handles user events, allows zooming, panning, etc.
- PAINTER/PCB_PAINTER - Classes that uses GAL interface to draw items (as you may have already guessed - PCB_PAINTER is a class for drawing PCB specific object, PAINTER is an abstract class). Its methods are invoked by VIEW, when an item has to be drawn. To display a new type of item - you need to implement draw(ITEM_TYPE*) method that draws it using GAL methods.
- STROKE_FONT - Implements stroke font drawing using GAL methods.
Most important changes to Kicad original code:
* EDA_ITEM now inherits from VIEW_ITEM, which is a base class for all drawable objects.
* EDA_DRAW_FRAME contains both usual EDA_DRAW_PANEL and new EDA_DRAW_PANEL_GAL, that can be switched anytime.
* There are some new layers for displaying multilayer pads, vias & pads holes (these are not shown yet on the right sidebar in pcbnew)
* Display order of layers is different than in previous versions (if you are curious - you may check m_galLayerOrder@pcbnew/basepcbframe.cpp). Preserving usual order would result in not very natural display, such as showing silkscreen texts on the bottom.
* Introduced new hotkey (Alt+F12) and new menu option (View->Switch canvas) for switching canvas during runtime.
* Some of classes (mostly derived from BOARD_ITEM) now includes ViewBBox & ViewGetLayers methods.
* Removed tools/class_painter.h, as now it is extended and included in source code.
Build changes:
* GAL-based rendering option is turned on by a new compilation CMake option KICAD_GAL.
* When compiling with CMake option KICAD_GAL=ON, GLEW and Cairo libraries are required.
* GAL-related code is compiled into a static library (common/libgal).
* Build with KICAD_GAL=OFF should not need any new libraries and should come out as a standard version of Kicad
Currently most of items in pcbnew can be displayed using OpenGL (to be done are DIMENSIONS and MARKERS).
More details about GAL can be found in: http://www.ohwr.org/attachments/1884/view-spec.pdf
2013-04-02 06:54:03 +00:00
|
|
|
}
|
2013-08-05 12:46:05 +00:00
|
|
|
|
2017-09-20 08:53:58 +00:00
|
|
|
|
2018-01-21 11:04:04 +00:00
|
|
|
bool EDA_DRAW_FRAME::SwitchCanvas( EDA_DRAW_PANEL_GAL::GAL_TYPE aCanvasType )
|
|
|
|
{
|
|
|
|
auto galCanvas = GetGalCanvas();
|
|
|
|
wxCHECK( galCanvas, false );
|
|
|
|
bool use_gal = galCanvas->SwitchBackend( aCanvasType );
|
|
|
|
use_gal &= aCanvasType != EDA_DRAW_PANEL_GAL::GAL_TYPE_NONE;
|
|
|
|
UseGalCanvas( use_gal );
|
|
|
|
m_canvasType = use_gal ? aCanvasType : EDA_DRAW_PANEL_GAL::GAL_TYPE_NONE;
|
|
|
|
|
|
|
|
return use_gal;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-08-03 19:41:57 +00:00
|
|
|
EDA_DRAW_PANEL_GAL::GAL_TYPE EDA_DRAW_FRAME::LoadCanvasTypeSetting()
|
2017-09-20 08:53:58 +00:00
|
|
|
{
|
|
|
|
EDA_DRAW_PANEL_GAL::GAL_TYPE canvasType = EDA_DRAW_PANEL_GAL::GAL_TYPE_NONE;
|
|
|
|
wxConfigBase* cfg = Kiface().KifaceSettings();
|
|
|
|
|
|
|
|
if( cfg )
|
2019-01-31 19:43:13 +00:00
|
|
|
{
|
|
|
|
canvasType = (EDA_DRAW_PANEL_GAL::GAL_TYPE)
|
|
|
|
cfg->ReadLong( GetCanvasTypeKey(), EDA_DRAW_PANEL_GAL::GAL_TYPE_NONE );
|
|
|
|
}
|
2017-09-20 08:53:58 +00:00
|
|
|
|
|
|
|
if( canvasType < EDA_DRAW_PANEL_GAL::GAL_TYPE_NONE
|
|
|
|
|| canvasType >= EDA_DRAW_PANEL_GAL::GAL_TYPE_LAST )
|
|
|
|
{
|
|
|
|
assert( false );
|
|
|
|
canvasType = EDA_DRAW_PANEL_GAL::GAL_TYPE_NONE;
|
|
|
|
}
|
|
|
|
|
2018-12-12 14:16:50 +00:00
|
|
|
// Coerce the value into a GAL type when Legacy is not available
|
2019-01-04 14:00:05 +00:00
|
|
|
// Default to Cairo, and on the first, user will be prompted for OpenGL
|
2018-12-12 14:16:50 +00:00
|
|
|
if( canvasType == EDA_DRAW_PANEL_GAL::GAL_TYPE_NONE
|
|
|
|
&& !ADVANCED_CFG::GetCfg().AllowLegacyCanvas() )
|
|
|
|
{
|
2019-01-31 19:43:13 +00:00
|
|
|
#ifdef __WXMAC__
|
|
|
|
// Cairo renderer doesn't handle Retina displays
|
|
|
|
canvasType = EDA_DRAW_PANEL_GAL::GAL_TYPE_OPENGL;
|
|
|
|
#else
|
2019-01-04 14:00:05 +00:00
|
|
|
canvasType = EDA_DRAW_PANEL_GAL::GAL_TYPE_CAIRO;
|
2019-01-31 19:43:13 +00:00
|
|
|
#endif
|
2018-12-12 14:16:50 +00:00
|
|
|
}
|
|
|
|
|
2017-09-20 08:53:58 +00:00
|
|
|
return canvasType;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool EDA_DRAW_FRAME::saveCanvasTypeSetting( EDA_DRAW_PANEL_GAL::GAL_TYPE aCanvasType )
|
|
|
|
{
|
2019-01-11 12:19:46 +00:00
|
|
|
// Not all classes derived from EDA_DRAW_FRAME can save the canvas type, because some
|
|
|
|
// have a fixed type, or do not have a option to set the canvas type (they inherit from
|
|
|
|
// a parent frame)
|
|
|
|
FRAME_T allowed_frames[] =
|
|
|
|
{
|
2019-05-19 18:25:01 +00:00
|
|
|
FRAME_SCH, FRAME_PCB, FRAME_PCB_MODULE_EDITOR, FRAME_GERBER
|
2019-01-11 12:19:46 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
bool allow_save = false;
|
|
|
|
|
2019-05-19 18:25:01 +00:00
|
|
|
for( FRAME_T frame : allowed_frames )
|
2019-01-11 12:19:46 +00:00
|
|
|
{
|
2019-05-19 18:25:01 +00:00
|
|
|
if( m_Ident == frame )
|
2019-01-11 12:19:46 +00:00
|
|
|
{
|
|
|
|
allow_save = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if( !allow_save )
|
|
|
|
return false;
|
|
|
|
|
2017-09-20 08:53:58 +00:00
|
|
|
if( aCanvasType < EDA_DRAW_PANEL_GAL::GAL_TYPE_NONE
|
|
|
|
|| aCanvasType >= EDA_DRAW_PANEL_GAL::GAL_TYPE_LAST )
|
|
|
|
{
|
2019-01-11 12:19:46 +00:00
|
|
|
wxASSERT( false );
|
2017-09-20 08:53:58 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
wxConfigBase* cfg = Kiface().KifaceSettings();
|
|
|
|
|
|
|
|
if( cfg )
|
2019-01-11 12:19:46 +00:00
|
|
|
return cfg->Write( GetCanvasTypeKey(), (long) aCanvasType );
|
2017-09-20 08:53:58 +00:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-08-03 05:15:23 +00:00
|
|
|
//-----< BASE_SCREEN API moved here >--------------------------------------------
|
|
|
|
|
|
|
|
wxPoint EDA_DRAW_FRAME::GetCrossHairPosition( bool aInvertY ) const
|
|
|
|
{
|
2013-08-03 06:36:51 +00:00
|
|
|
// subject to change, borrow from old BASE_SCREEN for now.
|
2014-03-19 13:26:02 +00:00
|
|
|
if( IsGalCanvasActive() )
|
|
|
|
{
|
|
|
|
VECTOR2I cursor = GetGalCanvas()->GetViewControls()->GetCursorPosition();
|
2013-08-03 06:36:51 +00:00
|
|
|
|
2014-03-19 13:26:02 +00:00
|
|
|
return wxPoint( cursor.x, cursor.y );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
BASE_SCREEN* screen = GetScreen(); // virtual call
|
|
|
|
return screen->getCrossHairPosition( aInvertY );
|
|
|
|
}
|
2013-08-03 05:15:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::SetCrossHairPosition( const wxPoint& aPosition, bool aSnapToGrid )
|
|
|
|
{
|
2013-08-03 06:36:51 +00:00
|
|
|
BASE_SCREEN* screen = GetScreen(); // virtual call
|
|
|
|
screen->setCrossHairPosition( aPosition, GetGridOrigin(), aSnapToGrid );
|
2013-08-03 05:15:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
wxPoint EDA_DRAW_FRAME::GetCursorPosition( bool aOnGrid, wxRealPoint* aGridSize ) const
|
|
|
|
{
|
2013-08-03 06:36:51 +00:00
|
|
|
BASE_SCREEN* screen = GetScreen(); // virtual call
|
|
|
|
return screen->getCursorPosition( aOnGrid, GetGridOrigin(), aGridSize );
|
2013-08-03 05:15:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
wxPoint EDA_DRAW_FRAME::GetNearestGridPosition( const wxPoint& aPosition, wxRealPoint* aGridSize ) const
|
|
|
|
{
|
2013-08-03 06:36:51 +00:00
|
|
|
BASE_SCREEN* screen = GetScreen(); // virtual call
|
|
|
|
return screen->getNearestGridPosition( aPosition, GetGridOrigin(), aGridSize );
|
2013-08-03 05:15:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
wxPoint EDA_DRAW_FRAME::GetCrossHairScreenPosition() const
|
|
|
|
{
|
2013-08-03 06:36:51 +00:00
|
|
|
BASE_SCREEN* screen = GetScreen(); // virtual call
|
|
|
|
return screen->getCrossHairScreenPosition();
|
2013-08-03 05:15:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::SetMousePosition( const wxPoint& aPosition )
|
|
|
|
{
|
2013-08-03 06:36:51 +00:00
|
|
|
BASE_SCREEN* screen = GetScreen(); // virtual call
|
|
|
|
screen->setMousePosition( aPosition );
|
2013-08-03 05:15:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
wxPoint EDA_DRAW_FRAME::RefPos( bool useMouse ) const
|
|
|
|
{
|
2013-08-03 06:36:51 +00:00
|
|
|
BASE_SCREEN* screen = GetScreen(); // virtual call
|
|
|
|
return screen->refPos( useMouse );
|
2013-08-03 05:15:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const wxPoint& EDA_DRAW_FRAME::GetScrollCenterPosition() const
|
|
|
|
{
|
2013-08-03 06:36:51 +00:00
|
|
|
BASE_SCREEN* screen = GetScreen(); // virtual call
|
|
|
|
return screen->getScrollCenterPosition();
|
2013-08-03 05:15:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::SetScrollCenterPosition( const wxPoint& aPoint )
|
|
|
|
{
|
2013-08-03 06:36:51 +00:00
|
|
|
BASE_SCREEN* screen = GetScreen(); // virtual call
|
|
|
|
screen->setScrollCenterPosition( aPoint );
|
2013-08-03 05:15:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//-----</BASE_SCREEN API moved here >--------------------------------------------
|
2014-06-12 16:12:14 +00:00
|
|
|
|
2018-07-27 20:47:51 +00:00
|
|
|
void EDA_DRAW_FRAME::RefreshCrossHair( const wxPoint &aOldPos, const wxPoint &aEvtPos, wxDC* aDC )
|
2014-06-12 16:12:14 +00:00
|
|
|
{
|
|
|
|
wxPoint newpos = GetCrossHairPosition();
|
|
|
|
|
|
|
|
// Redraw the crosshair if it moved
|
|
|
|
if( aOldPos != newpos )
|
|
|
|
{
|
|
|
|
SetCrossHairPosition( aOldPos, false );
|
|
|
|
m_canvas->CrossHairOff( aDC );
|
|
|
|
SetCrossHairPosition( newpos, false );
|
|
|
|
m_canvas->CrossHairOn( aDC );
|
|
|
|
|
|
|
|
if( m_canvas->IsMouseCaptured() )
|
|
|
|
{
|
|
|
|
#ifdef USE_WX_OVERLAY
|
|
|
|
wxDCOverlay oDC( m_overlay, (wxWindowDC*)aDC );
|
|
|
|
oDC.Clear();
|
|
|
|
m_canvas->CallMouseCapture( aDC, aEvtPos, false );
|
|
|
|
#else
|
|
|
|
m_canvas->CallMouseCapture( aDC, aEvtPos, true );
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#ifdef USE_WX_OVERLAY
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_overlay.Reset();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-27 20:47:51 +00:00
|
|
|
|
|
|
|
bool EDA_DRAW_FRAME::LibraryFileBrowser( bool doOpen, wxFileName& aFilename,
|
2018-11-04 12:32:54 +00:00
|
|
|
const wxString& wildcard, const wxString& ext,
|
|
|
|
bool isDirectory )
|
2018-07-27 20:47:51 +00:00
|
|
|
{
|
2018-11-04 12:32:54 +00:00
|
|
|
wxString prompt = doOpen ? _( "Select Library" ) : _( "New Library" );
|
2018-07-27 20:47:51 +00:00
|
|
|
aFilename.SetExt( ext );
|
|
|
|
|
2018-11-04 12:32:54 +00:00
|
|
|
#ifndef __WXMAC__
|
2019-01-22 13:21:26 +00:00
|
|
|
if( isDirectory && doOpen )
|
2018-11-04 12:32:54 +00:00
|
|
|
{
|
|
|
|
wxDirDialog dlg( this, prompt, Prj().GetProjectPath(),
|
2019-01-22 13:21:26 +00:00
|
|
|
wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST );
|
2018-07-27 20:47:51 +00:00
|
|
|
|
2018-11-04 12:32:54 +00:00
|
|
|
if( dlg.ShowModal() == wxID_CANCEL )
|
|
|
|
return false;
|
2018-07-27 20:47:51 +00:00
|
|
|
|
2018-11-04 12:32:54 +00:00
|
|
|
aFilename = dlg.GetPath();
|
|
|
|
aFilename.SetExt( ext );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
wxFileDialog dlg( this, prompt, Prj().GetProjectPath(), aFilename.GetFullName() ,
|
|
|
|
wildcard, doOpen ? wxFD_OPEN | wxFD_FILE_MUST_EXIST
|
|
|
|
: wxFD_SAVE | wxFD_CHANGE_DIR | wxFD_OVERWRITE_PROMPT );
|
|
|
|
|
|
|
|
if( dlg.ShowModal() == wxID_CANCEL )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
aFilename = dlg.GetPath();
|
|
|
|
aFilename.SetExt( ext );
|
|
|
|
}
|
2018-07-27 20:47:51 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool EDA_DRAW_FRAME::GeneralControlKeyMovement( int aHotKey, wxPoint *aPos, bool aSnapToGrid )
|
2014-06-12 16:12:14 +00:00
|
|
|
{
|
2017-10-06 07:23:13 +00:00
|
|
|
bool key_handled = false;
|
2014-06-12 16:12:14 +00:00
|
|
|
|
|
|
|
// If requested snap the current position to the grid
|
|
|
|
if( aSnapToGrid )
|
|
|
|
*aPos = GetNearestGridPosition( *aPos );
|
|
|
|
|
|
|
|
switch( aHotKey )
|
|
|
|
{
|
2015-05-03 06:31:14 +00:00
|
|
|
// All these keys have almost the same treatment
|
|
|
|
case GR_KB_CTRL | WXK_NUMPAD8:
|
|
|
|
case GR_KB_CTRL | WXK_UP:
|
|
|
|
case GR_KB_CTRL | WXK_NUMPAD2:
|
|
|
|
case GR_KB_CTRL | WXK_DOWN:
|
|
|
|
case GR_KB_CTRL | WXK_NUMPAD4:
|
|
|
|
case GR_KB_CTRL | WXK_LEFT:
|
|
|
|
case GR_KB_CTRL | WXK_NUMPAD6:
|
|
|
|
case GR_KB_CTRL | WXK_RIGHT:
|
|
|
|
case WXK_NUMPAD8:
|
|
|
|
case WXK_UP:
|
|
|
|
case WXK_NUMPAD2:
|
|
|
|
case WXK_DOWN:
|
|
|
|
case WXK_NUMPAD4:
|
|
|
|
case WXK_LEFT:
|
|
|
|
case WXK_NUMPAD6:
|
|
|
|
case WXK_RIGHT:
|
2017-10-06 07:23:13 +00:00
|
|
|
key_handled = true;
|
2014-06-12 16:12:14 +00:00
|
|
|
{
|
|
|
|
/* Here's a tricky part: when doing cursor key movement, the
|
|
|
|
* 'previous' point should be taken from memory, *not* from the
|
|
|
|
* freshly computed position in the event. Otherwise you can't do
|
|
|
|
* sub-pixel movement. The m_movingCursorWithKeyboard oneshot 'eats'
|
|
|
|
* the automatic motion event generated by cursor warping */
|
|
|
|
wxRealPoint gridSize = GetScreen()->GetGridSize();
|
|
|
|
*aPos = GetCrossHairPosition();
|
|
|
|
|
|
|
|
// Bonus: ^key moves faster (x10)
|
|
|
|
switch( aHotKey )
|
|
|
|
{
|
|
|
|
case GR_KB_CTRL|WXK_NUMPAD8:
|
|
|
|
case GR_KB_CTRL|WXK_UP:
|
|
|
|
aPos->y -= KiROUND( 10 * gridSize.y );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GR_KB_CTRL|WXK_NUMPAD2:
|
|
|
|
case GR_KB_CTRL|WXK_DOWN:
|
|
|
|
aPos->y += KiROUND( 10 * gridSize.y );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GR_KB_CTRL|WXK_NUMPAD4:
|
|
|
|
case GR_KB_CTRL|WXK_LEFT:
|
|
|
|
aPos->x -= KiROUND( 10 * gridSize.x );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GR_KB_CTRL|WXK_NUMPAD6:
|
|
|
|
case GR_KB_CTRL|WXK_RIGHT:
|
|
|
|
aPos->x += KiROUND( 10 * gridSize.x );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WXK_NUMPAD8:
|
|
|
|
case WXK_UP:
|
|
|
|
aPos->y -= KiROUND( gridSize.y );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WXK_NUMPAD2:
|
|
|
|
case WXK_DOWN:
|
|
|
|
aPos->y += KiROUND( gridSize.y );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WXK_NUMPAD4:
|
|
|
|
case WXK_LEFT:
|
|
|
|
aPos->x -= KiROUND( gridSize.x );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WXK_NUMPAD6:
|
|
|
|
case WXK_RIGHT:
|
|
|
|
aPos->x += KiROUND( gridSize.x );
|
|
|
|
break;
|
|
|
|
|
|
|
|
default: /* Can't happen since we entered the statement */
|
|
|
|
break;
|
|
|
|
}
|
2017-10-06 07:23:13 +00:00
|
|
|
|
2014-06-12 16:12:14 +00:00
|
|
|
m_canvas->MoveCursor( *aPos );
|
|
|
|
m_movingCursorWithKeyboard = true;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2017-10-06 07:23:13 +00:00
|
|
|
|
|
|
|
return key_handled;
|
2014-06-12 16:12:14 +00:00
|
|
|
}
|
2017-04-25 09:06:24 +00:00
|
|
|
|
2017-09-21 16:37:12 +00:00
|
|
|
|
|
|
|
bool EDA_DRAW_FRAME::isBusy() const
|
|
|
|
{
|
|
|
|
const BASE_SCREEN* screen = const_cast< BASE_SCREEN* >( GetScreen() );
|
|
|
|
|
|
|
|
if( !screen )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return ( screen->GetCurItem() && screen->GetCurItem()->GetFlags() )
|
|
|
|
|| ( screen->m_BlockLocate.GetState() != STATE_NO_BLOCK );
|
|
|
|
}
|
2018-08-03 11:51:41 +00:00
|
|
|
|
2018-11-09 13:32:13 +00:00
|
|
|
|
2018-08-03 11:51:41 +00:00
|
|
|
void EDA_DRAW_FRAME::RedrawScreen( const wxPoint& aCenterPoint, bool aWarpPointer )
|
|
|
|
{
|
|
|
|
if( IsGalCanvasActive() )
|
|
|
|
return;
|
|
|
|
|
|
|
|
AdjustScrollBars( aCenterPoint );
|
|
|
|
|
|
|
|
// Move the mouse cursor to the on grid graphic cursor position
|
|
|
|
if( aWarpPointer )
|
|
|
|
m_canvas->MoveCursorToCrossHair();
|
|
|
|
|
|
|
|
m_canvas->Refresh();
|
|
|
|
m_canvas->Update();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::RedrawScreen2( const wxPoint& posBefore )
|
|
|
|
{
|
|
|
|
if( IsGalCanvasActive() )
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Account for scrollbars (see EDA_DRAW_FRAME::AdjustScrollBars that takes
|
|
|
|
// in account scroolbars area to adjust scroll bars)
|
|
|
|
wxSize scrollbarSize = m_canvas->GetSize() - m_canvas->GetClientSize();
|
|
|
|
wxSize sizeAdjusted = m_canvas->GetClientSize() - scrollbarSize;
|
|
|
|
|
|
|
|
wxPoint dPos = posBefore - sizeAdjusted / 2;
|
|
|
|
|
|
|
|
// screen position of crosshair after zoom
|
|
|
|
wxPoint newScreenPos = m_canvas->ToDeviceXY( GetCrossHairPosition() );
|
|
|
|
wxPoint newCenter = m_canvas->ToLogicalXY( newScreenPos - dPos );
|
|
|
|
|
|
|
|
AdjustScrollBars( newCenter );
|
|
|
|
|
|
|
|
m_canvas->Refresh();
|
|
|
|
m_canvas->Update();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-09-05 22:17:22 +00:00
|
|
|
void EDA_DRAW_FRAME::HardRedraw()
|
|
|
|
{
|
|
|
|
m_canvas->Refresh();
|
|
|
|
m_canvas->Update();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-08-03 11:51:41 +00:00
|
|
|
// Factor out the calculation portion of the various BestZoom() implementations.
|
|
|
|
//
|
|
|
|
// Note that like it's forerunners this routine has an intentional side-effect: it
|
|
|
|
// sets the scroll centre position. While I'm not happy about that, it's probably
|
|
|
|
// not worth fixing as its days are numbered (GAL canvases use a different method).
|
|
|
|
double EDA_DRAW_FRAME::bestZoom( double sizeX, double sizeY, double scaleFactor, wxPoint centre )
|
|
|
|
{
|
|
|
|
double bestzoom = std::max( sizeX * scaleFactor / (double) m_canvas->GetClientSize().x,
|
|
|
|
sizeY * scaleFactor / (double) m_canvas->GetClientSize().y );
|
|
|
|
|
|
|
|
// Take scrollbars into account
|
|
|
|
DSIZE scrollbarSize = m_canvas->GetSize() - m_canvas->GetClientSize();
|
|
|
|
centre.x -= int( bestzoom * scrollbarSize.x / 2.0 );
|
|
|
|
centre.y -= int( bestzoom * scrollbarSize.y / 2.0 );
|
|
|
|
|
|
|
|
SetScrollCenterPosition( centre );
|
|
|
|
|
|
|
|
return bestzoom;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::Zoom_Automatique( bool aWarpPointer )
|
|
|
|
{
|
|
|
|
BASE_SCREEN* screen = GetScreen();
|
|
|
|
|
|
|
|
// Set the best zoom and get center point.
|
|
|
|
|
|
|
|
// BestZoom() can compute an illegal zoom if the client window size
|
|
|
|
// is small, say because frame is not maximized. So use the clamping form
|
|
|
|
// of SetZoom():
|
|
|
|
double bestzoom = BestZoom();
|
|
|
|
screen->SetScalingFactor( bestzoom );
|
|
|
|
|
2018-09-16 21:19:33 +00:00
|
|
|
if( !screen->m_Initialized )
|
2018-08-03 11:51:41 +00:00
|
|
|
SetCrossHairPosition( GetScrollCenterPosition() );
|
|
|
|
|
|
|
|
if( !IsGalCanvasActive() )
|
|
|
|
RedrawScreen( GetScrollCenterPosition(), aWarpPointer );
|
|
|
|
else
|
|
|
|
m_toolManager->RunAction( "common.Control.zoomFitScreen", true );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::Window_Zoom( EDA_RECT& Rect )
|
|
|
|
{
|
|
|
|
// Compute the best zoom
|
|
|
|
Rect.Normalize();
|
|
|
|
|
|
|
|
wxSize size = m_canvas->GetClientSize();
|
|
|
|
|
|
|
|
// Use ceil to at least show the full rect
|
|
|
|
double scalex = (double) Rect.GetSize().x / size.x;
|
|
|
|
double bestscale = (double) Rect.GetSize().y / size.y;
|
|
|
|
|
|
|
|
bestscale = std::max( bestscale, scalex );
|
|
|
|
|
|
|
|
GetScreen()->SetScalingFactor( bestscale );
|
|
|
|
RedrawScreen( Rect.Centre(), true );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::OnZoom( wxCommandEvent& event )
|
|
|
|
{
|
|
|
|
if( m_canvas == NULL )
|
|
|
|
return;
|
|
|
|
|
|
|
|
int id = event.GetId();
|
|
|
|
bool zoom_at_cursor = false;
|
|
|
|
BASE_SCREEN* screen = GetScreen();
|
|
|
|
wxPoint center = GetScrollCenterPosition();
|
|
|
|
|
|
|
|
if ( id == ID_KEY_ZOOM_IN )
|
|
|
|
{
|
|
|
|
id = GetCanvas()->GetEnableZoomNoCenter() ?
|
|
|
|
ID_OFFCENTER_ZOOM_IN : ID_POPUP_ZOOM_IN;
|
|
|
|
}
|
|
|
|
else if ( id == ID_KEY_ZOOM_OUT )
|
|
|
|
{
|
|
|
|
id = GetCanvas()->GetEnableZoomNoCenter() ?
|
|
|
|
ID_OFFCENTER_ZOOM_OUT : ID_POPUP_ZOOM_OUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch( id )
|
|
|
|
{
|
|
|
|
case ID_OFFCENTER_ZOOM_IN:
|
|
|
|
center = m_canvas->ToDeviceXY( GetCrossHairPosition() );
|
|
|
|
|
|
|
|
if( screen->SetPreviousZoom() )
|
|
|
|
RedrawScreen2( center );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ID_POPUP_ZOOM_IN:
|
|
|
|
zoom_at_cursor = true;
|
|
|
|
center = GetCrossHairPosition();
|
|
|
|
|
|
|
|
// fall thru
|
|
|
|
case ID_VIEWER_ZOOM_IN:
|
|
|
|
case ID_ZOOM_IN:
|
|
|
|
if( screen->SetPreviousZoom() )
|
|
|
|
RedrawScreen( center, zoom_at_cursor );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ID_OFFCENTER_ZOOM_OUT:
|
|
|
|
center = m_canvas->ToDeviceXY( GetCrossHairPosition() );
|
|
|
|
|
|
|
|
if( screen->SetNextZoom() )
|
|
|
|
RedrawScreen2( center );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ID_POPUP_ZOOM_OUT:
|
|
|
|
zoom_at_cursor = true;
|
|
|
|
center = GetCrossHairPosition();
|
|
|
|
|
|
|
|
// fall thru
|
|
|
|
case ID_VIEWER_ZOOM_OUT:
|
|
|
|
case ID_ZOOM_OUT:
|
|
|
|
if( screen->SetNextZoom() )
|
|
|
|
RedrawScreen( center, zoom_at_cursor );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ID_VIEWER_ZOOM_REDRAW:
|
|
|
|
case ID_POPUP_ZOOM_REDRAW:
|
|
|
|
case ID_ZOOM_REDRAW:
|
2018-09-05 12:46:29 +00:00
|
|
|
// This usually means something went wrong. Do a hard refresh.
|
|
|
|
SetScreen( GetScreen() );
|
2018-08-03 11:51:41 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ID_POPUP_ZOOM_CENTER:
|
|
|
|
center = GetCrossHairPosition();
|
|
|
|
RedrawScreen( center, true );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ID_POPUP_ZOOM_PAGE:
|
|
|
|
case ID_VIEWER_ZOOM_PAGE:
|
|
|
|
case ID_ZOOM_PAGE:
|
|
|
|
Zoom_Automatique( false );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ID_POPUP_ZOOM_SELECT:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ID_POPUP_CANCEL:
|
|
|
|
m_canvas->MoveCursorToCrossHair();
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
SetPresetZoom( id - ID_POPUP_ZOOM_LEVEL_START );
|
|
|
|
}
|
|
|
|
|
|
|
|
UpdateStatusBar();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::SetNextZoom()
|
|
|
|
{
|
|
|
|
GetScreen()->SetNextZoom();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::SetPrevZoom()
|
|
|
|
{
|
|
|
|
GetScreen()->SetPreviousZoom();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::SetPresetZoom( int aIndex )
|
|
|
|
{
|
|
|
|
BASE_SCREEN* screen = GetScreen();
|
|
|
|
|
|
|
|
if( aIndex >= (int) screen->m_ZoomList.size() )
|
|
|
|
{
|
|
|
|
wxLogDebug( wxT( "%s %d: index %d is outside the bounds of the zoom list." ),
|
|
|
|
__TFILE__, __LINE__, aIndex );
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( m_zoomSelectBox )
|
|
|
|
m_zoomSelectBox->SetSelection( aIndex );
|
|
|
|
|
|
|
|
if( screen->SetZoom( screen->m_ZoomList[aIndex] ) )
|
|
|
|
RedrawScreen( GetScrollCenterPosition(), true );
|
|
|
|
|
|
|
|
UpdateStatusBar();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::AddMenuZoomAndGrid( wxMenu* MasterMenu )
|
|
|
|
{
|
|
|
|
int maxZoomIds;
|
|
|
|
double zoom;
|
|
|
|
wxString msg;
|
|
|
|
BASE_SCREEN* screen = m_canvas->GetScreen();
|
|
|
|
|
|
|
|
msg = AddHotkeyName( _( "Center" ), m_hotkeysDescrList, HK_ZOOM_CENTER );
|
|
|
|
AddMenuItem( MasterMenu, ID_POPUP_ZOOM_CENTER, msg, KiBitmap( zoom_center_on_screen_xpm ) );
|
|
|
|
msg = AddHotkeyName( _( "Zoom In" ), m_hotkeysDescrList, HK_ZOOM_IN );
|
|
|
|
AddMenuItem( MasterMenu, ID_POPUP_ZOOM_IN, msg, KiBitmap( zoom_in_xpm ) );
|
|
|
|
msg = AddHotkeyName( _( "Zoom Out" ), m_hotkeysDescrList, HK_ZOOM_OUT );
|
|
|
|
AddMenuItem( MasterMenu, ID_POPUP_ZOOM_OUT, msg, KiBitmap( zoom_out_xpm ) );
|
|
|
|
msg = AddHotkeyName( _( "Redraw View" ), m_hotkeysDescrList, HK_ZOOM_REDRAW );
|
|
|
|
AddMenuItem( MasterMenu, ID_POPUP_ZOOM_REDRAW, msg, KiBitmap( zoom_redraw_xpm ) );
|
|
|
|
msg = AddHotkeyName( _( "Zoom to Fit" ), m_hotkeysDescrList, HK_ZOOM_AUTO );
|
|
|
|
AddMenuItem( MasterMenu, ID_POPUP_ZOOM_PAGE, msg, KiBitmap( zoom_fit_in_page_xpm ) );
|
|
|
|
|
|
|
|
|
|
|
|
wxMenu* zoom_choice = new wxMenu;
|
|
|
|
AddMenuItem( MasterMenu, zoom_choice,
|
|
|
|
ID_POPUP_ZOOM_SELECT, _( "Zoom" ),
|
|
|
|
KiBitmap( zoom_selection_xpm ) );
|
|
|
|
|
|
|
|
zoom = screen->GetZoom();
|
|
|
|
maxZoomIds = ID_POPUP_ZOOM_LEVEL_END - ID_POPUP_ZOOM_LEVEL_START;
|
|
|
|
maxZoomIds = ( (size_t) maxZoomIds < screen->m_ZoomList.size() ) ?
|
|
|
|
maxZoomIds : screen->m_ZoomList.size();
|
|
|
|
|
|
|
|
// Populate zoom submenu.
|
|
|
|
for( int i = 0; i < maxZoomIds; i++ )
|
|
|
|
{
|
|
|
|
msg.Printf( wxT( "%.2f" ), m_zoomLevelCoeff / screen->m_ZoomList[i] );
|
|
|
|
|
|
|
|
zoom_choice->Append( ID_POPUP_ZOOM_LEVEL_START + i, _( "Zoom: " ) + msg,
|
|
|
|
wxEmptyString, wxITEM_CHECK );
|
|
|
|
if( zoom == screen->m_ZoomList[i] )
|
|
|
|
zoom_choice->Check( ID_POPUP_ZOOM_LEVEL_START + i, true );
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create grid submenu as required.
|
|
|
|
if( screen->GetGridCount() )
|
|
|
|
{
|
|
|
|
wxMenu* gridMenu = new wxMenu;
|
|
|
|
AddMenuItem( MasterMenu, gridMenu, ID_POPUP_GRID_SELECT,
|
|
|
|
_( "Grid" ), KiBitmap( grid_select_xpm ) );
|
|
|
|
|
|
|
|
wxArrayString gridsList;
|
|
|
|
int icurr = screen->BuildGridsChoiceList( gridsList, GetUserUnits() != INCHES );
|
|
|
|
|
|
|
|
for( unsigned i = 0; i < gridsList.GetCount(); i++ )
|
|
|
|
{
|
|
|
|
GRID_TYPE& grid = screen->GetGrid( i );
|
|
|
|
gridMenu->Append( grid.m_CmdId, gridsList[i], wxEmptyString, wxITEM_CHECK );
|
|
|
|
|
|
|
|
if( (int)i == icurr )
|
|
|
|
gridMenu->Check( grid.m_CmdId, true );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
MasterMenu->AppendSeparator();
|
|
|
|
AddMenuItem( MasterMenu, ID_POPUP_CANCEL, _( "Close" ), KiBitmap( cancel_xpm ) );
|
|
|
|
}
|
|
|
|
|
2018-11-09 13:32:13 +00:00
|
|
|
|
2018-11-14 23:34:32 +00:00
|
|
|
// Find the first child dialog.
|
|
|
|
wxWindow* findDialog( wxWindowList& aList )
|
|
|
|
{
|
|
|
|
for( wxWindow* window : aList )
|
|
|
|
{
|
|
|
|
if( dynamic_cast<DIALOG_SHIM*>( window ) )
|
|
|
|
return window;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::FocusOnLocation( const wxPoint& aPos, bool aWarpCursor, bool aCenterView )
|
|
|
|
{
|
|
|
|
if( IsGalCanvasActive() )
|
|
|
|
{
|
|
|
|
if( aCenterView )
|
|
|
|
{
|
|
|
|
wxWindow* dialog = findDialog( GetChildren() );
|
|
|
|
|
|
|
|
// If a dialog partly obscures the window, then center on the uncovered area.
|
|
|
|
if( dialog )
|
|
|
|
{
|
|
|
|
wxRect dialogRect( GetGalCanvas()->ScreenToClient( dialog->GetScreenPosition() ),
|
|
|
|
dialog->GetSize() );
|
|
|
|
GetGalCanvas()->GetView()->SetCenter( aPos, dialogRect );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
GetGalCanvas()->GetView()->SetCenter( aPos );
|
|
|
|
}
|
|
|
|
|
|
|
|
if( aWarpCursor )
|
|
|
|
GetGalCanvas()->GetViewControls()->SetCursorPosition( aPos );
|
|
|
|
else
|
|
|
|
GetGalCanvas()->GetViewControls()->SetCrossHairCursorPosition( aPos );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
INSTALL_UNBUFFERED_DC( dc, m_canvas );
|
|
|
|
|
|
|
|
// There may be need to reframe the drawing.
|
|
|
|
if( aCenterView || !m_canvas->IsPointOnDisplay( aPos ) )
|
|
|
|
{
|
|
|
|
SetCrossHairPosition( aPos );
|
|
|
|
RedrawScreen( aPos, aWarpCursor );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Put cursor on item position
|
|
|
|
m_canvas->CrossHairOff( &dc );
|
|
|
|
SetCrossHairPosition( aPos );
|
|
|
|
|
|
|
|
if( aWarpCursor )
|
|
|
|
m_canvas->MoveCursorToCrossHair();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Be sure cross hair cursor is ON:
|
|
|
|
m_canvas->CrossHairOn( &dc );
|
|
|
|
m_canvas->CrossHairOn( &dc );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-08-03 11:51:41 +00:00
|
|
|
static bool DrawPageOnClipboard( EDA_DRAW_FRAME* aFrame );
|
|
|
|
|
2018-11-09 13:32:13 +00:00
|
|
|
|
2018-08-03 11:51:41 +00:00
|
|
|
void EDA_DRAW_FRAME::CopyToClipboard( wxCommandEvent& event )
|
|
|
|
{
|
|
|
|
DrawPageOnClipboard( this );
|
|
|
|
|
|
|
|
if( event.GetId() == ID_GEN_COPY_BLOCK_TO_CLIPBOARD )
|
|
|
|
{
|
|
|
|
if( GetScreen()->IsBlockActive() )
|
|
|
|
m_canvas->SetCursor( wxCursor( (wxStockCursor) m_canvas->GetDefaultCursor() ) );
|
|
|
|
|
|
|
|
m_canvas->EndMouseCapture();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* copy the current page or block to the clipboard ,
|
|
|
|
* to export drawings to other applications (word processing ...)
|
|
|
|
* This is not suitable for copy command within Eeschema or Pcbnew
|
|
|
|
*/
|
|
|
|
bool DrawPageOnClipboard( EDA_DRAW_FRAME* aFrame )
|
|
|
|
{
|
|
|
|
bool DrawBlock = false;
|
|
|
|
wxRect DrawArea;
|
|
|
|
BASE_SCREEN* screen = aFrame->GetCanvas()->GetScreen();
|
|
|
|
|
|
|
|
if( screen->IsBlockActive() )
|
|
|
|
{
|
|
|
|
DrawBlock = true;
|
|
|
|
DrawArea.SetX( screen->m_BlockLocate.GetX() );
|
|
|
|
DrawArea.SetY( screen->m_BlockLocate.GetY() );
|
|
|
|
DrawArea.SetWidth( screen->m_BlockLocate.GetWidth() );
|
|
|
|
DrawArea.SetHeight( screen->m_BlockLocate.GetHeight() );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
DrawArea.SetSize( aFrame->GetPageSizeIU() );
|
|
|
|
|
|
|
|
// Calculate a reasonable dc size, in pixels, and the dc scale to fit
|
|
|
|
// the drawings into the dc size
|
|
|
|
// scale is the ratio resolution (in PPI) / internal units
|
|
|
|
double ppi = 300; // Use 300 pixels per inch to create bitmap images on start
|
|
|
|
double inch2Iu = 1000.0 * (double) screen->MilsToIuScalar();
|
|
|
|
double scale = ppi / inch2Iu;
|
|
|
|
|
|
|
|
wxSize dcsize = DrawArea.GetSize();
|
|
|
|
|
|
|
|
int maxdim = std::max( dcsize.x, dcsize.y );
|
2018-11-09 13:32:13 +00:00
|
|
|
|
2018-08-03 11:51:41 +00:00
|
|
|
// the max size in pixels of the bitmap used to byuild the sheet copy
|
|
|
|
const int maxbitmapsize = 3000;
|
|
|
|
|
|
|
|
while( int( maxdim * scale ) > maxbitmapsize )
|
|
|
|
{
|
|
|
|
ppi = ppi / 1.5;
|
|
|
|
scale = ppi / inch2Iu;
|
|
|
|
}
|
|
|
|
|
|
|
|
dcsize.x *= scale;
|
|
|
|
dcsize.y *= scale;
|
|
|
|
|
|
|
|
// Set draw offset, zoom... to values needed to draw in the memory DC
|
|
|
|
// after saving initial values:
|
|
|
|
wxPoint tmp_startvisu = screen->m_StartVisu;
|
|
|
|
double tmpzoom = screen->GetZoom();
|
|
|
|
wxPoint old_org = screen->m_DrawOrg;
|
|
|
|
screen->m_DrawOrg.x = screen->m_DrawOrg.y = 0;
|
|
|
|
screen->m_StartVisu.x = screen->m_StartVisu.y = 0;
|
|
|
|
|
|
|
|
screen->SetZoom( 1 ); // we use zoom = 1 in draw functions.
|
|
|
|
|
|
|
|
wxMemoryDC dc;
|
|
|
|
wxBitmap image( dcsize );
|
|
|
|
dc.SelectObject( image );
|
|
|
|
|
|
|
|
EDA_RECT tmp = *aFrame->GetCanvas()->GetClipBox();
|
|
|
|
GRResetPenAndBrush( &dc );
|
|
|
|
GRForceBlackPen( false );
|
|
|
|
screen->m_IsPrinting = true;
|
|
|
|
dc.SetUserScale( scale, scale );
|
|
|
|
|
|
|
|
aFrame->GetCanvas()->SetClipBox( EDA_RECT( wxPoint( 0, 0 ),
|
|
|
|
wxSize( 0x7FFFFF0, 0x7FFFFF0 ) ) );
|
|
|
|
|
|
|
|
if( DrawBlock )
|
|
|
|
{
|
|
|
|
dc.SetClippingRegion( DrawArea );
|
|
|
|
}
|
|
|
|
|
|
|
|
dc.Clear();
|
|
|
|
aFrame->GetCanvas()->EraseScreen( &dc );
|
|
|
|
const LSET allLayersMask = LSET().set();
|
|
|
|
aFrame->PrintPage( &dc, allLayersMask, false );
|
|
|
|
screen->m_IsPrinting = false;
|
|
|
|
aFrame->GetCanvas()->SetClipBox( tmp );
|
|
|
|
|
|
|
|
bool success = true;
|
|
|
|
|
|
|
|
if( wxTheClipboard->Open() )
|
|
|
|
{
|
|
|
|
// This data objects are held by the clipboard,
|
|
|
|
// so do not delete them in the app.
|
|
|
|
wxBitmapDataObject* clipbrd_data = new wxBitmapDataObject( image );
|
|
|
|
wxTheClipboard->SetData( clipbrd_data );
|
|
|
|
wxTheClipboard->Close();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
success = false;
|
|
|
|
|
|
|
|
// Deselect Bitmap from DC in order to delete the MemoryDC safely
|
|
|
|
// without deleting the bitmap
|
|
|
|
dc.SelectObject( wxNullBitmap );
|
|
|
|
|
|
|
|
GRForceBlackPen( false );
|
|
|
|
|
|
|
|
screen->m_StartVisu = tmp_startvisu;
|
|
|
|
screen->m_DrawOrg = old_org;
|
|
|
|
screen->SetZoom( tmpzoom );
|
|
|
|
|
|
|
|
return success;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void DrawPageLayout( wxDC* aDC, EDA_RECT* aClipBox,
|
|
|
|
const PAGE_INFO& aPageInfo,
|
|
|
|
const wxString &aFullSheetName,
|
|
|
|
const wxString& aFileName,
|
|
|
|
TITLE_BLOCK& aTitleBlock,
|
|
|
|
int aSheetCount, int aSheetNumber,
|
|
|
|
int aPenWidth, double aScalar,
|
|
|
|
COLOR4D aColor, COLOR4D aAltColor,
|
|
|
|
const wxString& aSheetLayer )
|
|
|
|
{
|
|
|
|
WS_DRAW_ITEM_LIST drawList;
|
|
|
|
|
|
|
|
drawList.SetPenSize( aPenWidth );
|
|
|
|
drawList.SetMilsToIUfactor( aScalar );
|
|
|
|
drawList.SetSheetNumber( aSheetNumber );
|
|
|
|
drawList.SetSheetCount( aSheetCount );
|
|
|
|
drawList.SetFileName( aFileName );
|
|
|
|
drawList.SetSheetName( aFullSheetName );
|
|
|
|
drawList.SetSheetLayer( aSheetLayer );
|
|
|
|
|
|
|
|
drawList.BuildWorkSheetGraphicList( aPageInfo,
|
|
|
|
aTitleBlock, aColor, aAltColor );
|
|
|
|
|
|
|
|
// Draw item list
|
|
|
|
drawList.Draw( aClipBox, aDC );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::DrawWorkSheet( wxDC* aDC, BASE_SCREEN* aScreen, int aLineWidth,
|
2018-11-09 13:32:13 +00:00
|
|
|
double aScalar, const wxString &aFilename,
|
2019-05-26 18:25:21 +00:00
|
|
|
const wxString &aSheetLayer, COLOR4D aColor )
|
2018-08-03 11:51:41 +00:00
|
|
|
{
|
|
|
|
if( !m_showBorderAndTitleBlock )
|
|
|
|
return;
|
|
|
|
|
|
|
|
const PAGE_INFO& pageInfo = GetPageSettings();
|
|
|
|
wxSize pageSize = pageInfo.GetSizeMils();
|
|
|
|
|
|
|
|
// if not printing, draw the page limits:
|
|
|
|
if( !aScreen->m_IsPrinting && m_showPageLimits )
|
|
|
|
{
|
|
|
|
GRSetDrawMode( aDC, GR_COPY );
|
|
|
|
GRRect( m_canvas->GetClipBox(), aDC, 0, 0,
|
|
|
|
pageSize.x * aScalar, pageSize.y * aScalar, aLineWidth,
|
|
|
|
m_drawBgColor == WHITE ? LIGHTGRAY : DARKDARKGRAY );
|
|
|
|
}
|
|
|
|
|
|
|
|
TITLE_BLOCK t_block = GetTitleBlock();
|
2019-05-26 18:25:21 +00:00
|
|
|
COLOR4D color = ( aColor != COLOR4D::UNSPECIFIED ) ? aColor : COLOR4D( RED );
|
2018-08-03 11:51:41 +00:00
|
|
|
|
|
|
|
wxPoint origin = aDC->GetDeviceOrigin();
|
|
|
|
|
|
|
|
if( aScreen->m_IsPrinting && origin.y > 0 )
|
|
|
|
{
|
|
|
|
aDC->SetDeviceOrigin( 0, 0 );
|
|
|
|
aDC->SetAxisOrientation( true, false );
|
|
|
|
}
|
|
|
|
|
|
|
|
DrawPageLayout( aDC, m_canvas->GetClipBox(), pageInfo,
|
|
|
|
GetScreenDesc(), aFilename, t_block,
|
|
|
|
aScreen->m_NumberOfScreens, aScreen->m_ScreenNumber,
|
|
|
|
aLineWidth, aScalar, color, color, aSheetLayer );
|
|
|
|
|
|
|
|
if( aScreen->m_IsPrinting && origin.y > 0 )
|
|
|
|
{
|
|
|
|
aDC->SetDeviceOrigin( origin.x, origin.y );
|
|
|
|
aDC->SetAxisOrientation( true, true );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
wxString EDA_DRAW_FRAME::GetScreenDesc() const
|
|
|
|
{
|
|
|
|
// Virtual function. In basic class, returns
|
|
|
|
// an empty string.
|
|
|
|
return wxEmptyString;
|
|
|
|
}
|
|
|
|
|
2018-11-09 13:32:13 +00:00
|
|
|
|
2018-08-03 11:51:41 +00:00
|
|
|
const BOX2I EDA_DRAW_FRAME::GetDocumentExtents() const
|
|
|
|
{
|
|
|
|
BOX2I rv;
|
|
|
|
rv.SetMaximum();
|
|
|
|
return rv;
|
|
|
|
}
|
2018-11-09 13:32:13 +00:00
|
|
|
|
|
|
|
|
|
|
|
bool EDA_DRAW_FRAME::saveCanvasImageToFile( const wxString& aFileName, wxBitmapType aBitmapType )
|
|
|
|
{
|
|
|
|
return SaveCanvasImageToFile( this, aFileName, aBitmapType );
|
|
|
|
}
|