2011-11-07 19:04:24 +00:00
|
|
|
/*
|
|
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
|
|
*
|
2015-01-22 13:42:24 +00:00
|
|
|
* Copyright (C) 2004-2015 Jean-Pierre Charras, jean-pierre.charras@gipsa-lab.inpg.fr
|
|
|
|
* Copyright (C) 2008-2015 Wayne Stambaugh <stambaughw@verizon.net>
|
2016-05-11 03:33:24 +00:00
|
|
|
* Copyright (C) 2004-2016 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>
|
2014-04-04 09:56:04 +00:00
|
|
|
#include <class_draw_panel_gal.h>
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <class_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>
|
2007-05-06 16:03:28 +00:00
|
|
|
|
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>
|
2017-02-15 05:32:25 +00:00
|
|
|
#include <gal/gal_display_options.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
|
|
|
|
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
|
|
|
|
|
|
|
|
/// Nonzero to show grid (suffix)
|
2010-02-01 21:23:27 +00:00
|
|
|
static const wxString ShowGridEntryKeyword( wxT( "ShowGrid" ) );
|
2016-05-12 19:45:47 +00:00
|
|
|
/// Grid color ID (suffix)
|
2010-02-01 21:23:27 +00:00
|
|
|
static const wxString GridColorEntryKeyword( wxT( "GridColor" ) );
|
2016-05-12 19:45:47 +00:00
|
|
|
/// Most recently used grid size (suffix)
|
2014-02-02 19:51:50 +00:00
|
|
|
static const wxString LastGridSizeIdKeyword( wxT( "_LastGridSize" ) );
|
2016-12-23 15:21:00 +00:00
|
|
|
/// GAL Display Options
|
|
|
|
static const wxString GalDisplayOptionsKeyword( wxT( "GalDisplayOptions" ) );
|
2009-04-05 20:49:15 +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 )
|
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
|
|
|
|
|
|
|
// Cursor shape cannot be implemented on OS X
|
|
|
|
#ifndef __APPLE__
|
2011-02-21 13:54:29 +00:00
|
|
|
EVT_TOOL( ID_TB_OPTIONS_SELECT_CURSOR, EDA_DRAW_FRAME::OnToggleCrossHairStyle )
|
2016-05-11 03:33:24 +00:00
|
|
|
#endif // !__APPLE__
|
2011-02-21 13:54:29 +00:00
|
|
|
|
|
|
|
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 ) :
|
2017-02-15 05:32:25 +00:00
|
|
|
KIWAY_PLAYER( aKiway, aParent, aFrameType, aTitle, aPos, aSize, aStyle, aFrameName ),
|
|
|
|
m_galDisplayOptions( std::make_unique<KIGFX::GAL_DISPLAY_OPTIONS>() )
|
2007-08-15 02:43:57 +00:00
|
|
|
{
|
2011-12-14 20:03:15 +00:00
|
|
|
m_drawToolBar = NULL;
|
|
|
|
m_optionsToolBar = NULL;
|
|
|
|
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;
|
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
|
|
|
|
2014-01-13 15:09:52 +00:00
|
|
|
m_auimgr.SetFlags(wxAUI_MGR_DEFAULT|wxAUI_MGR_LIVE_RESIZE);
|
|
|
|
|
2007-08-15 02:43:57 +00:00
|
|
|
CreateStatusBar( 6 );
|
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,
|
|
|
|
|
|
|
|
// 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
|
|
|
};
|
|
|
|
|
|
|
|
SetStatusWidths( DIM( 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
|
|
|
{
|
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();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::OnSelectUnits( wxCommandEvent& aEvent )
|
|
|
|
{
|
|
|
|
if( aEvent.GetId() == ID_TB_OPTIONS_SELECT_UNIT_MM && g_UserUnit != MILLIMETRES )
|
|
|
|
{
|
|
|
|
g_UserUnit = MILLIMETRES;
|
2011-03-01 19:26:17 +00:00
|
|
|
unitsChangeRefresh();
|
2011-02-21 13:54:29 +00:00
|
|
|
}
|
|
|
|
else if( aEvent.GetId() == ID_TB_OPTIONS_SELECT_UNIT_INCH && g_UserUnit != INCHES )
|
|
|
|
{
|
|
|
|
g_UserUnit = 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;
|
|
|
|
|
|
|
|
enable = ( ((aEvent.GetId() == ID_TB_OPTIONS_SELECT_UNIT_MM) && (g_UserUnit == MILLIMETRES))
|
|
|
|
|| ((aEvent.GetId() == ID_TB_OPTIONS_SELECT_UNIT_INCH) && (g_UserUnit == INCHES)) );
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2015-05-05 18:39:42 +00:00
|
|
|
int EDA_DRAW_FRAME::WriteHotkeyConfig( struct EDA_HOTKEY_CONFIG* aDescList, wxString* aFullFileName )
|
|
|
|
{
|
|
|
|
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
|
|
|
|
2015-07-02 09:50:38 +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 );
|
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
|
|
|
|
2015-04-30 08:46:04 +00:00
|
|
|
// Notify GAL
|
|
|
|
TOOL_MANAGER* mgr = GetToolManager();
|
2013-07-07 00:30:28 +00:00
|
|
|
|
2015-04-30 08:46:04 +00:00
|
|
|
if( mgr && IsGalCanvasActive() )
|
2015-05-12 09:05:36 +00:00
|
|
|
{
|
2015-04-30 08:46:04 +00:00
|
|
|
mgr->RunAction( "common.Control.gridPreset", true, idx );
|
2015-05-12 09:05:36 +00:00
|
|
|
}
|
2015-04-30 08:46:04 +00:00
|
|
|
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
|
|
|
|
2009-11-23 15:16:50 +00:00
|
|
|
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 );
|
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
|
|
|
{
|
|
|
|
id--;
|
2012-04-16 03:18:41 +00:00
|
|
|
double selectedZoom = GetScreen()->m_ZoomList[id];
|
2011-01-31 18:26:12 +00:00
|
|
|
|
2011-02-05 02:21:11 +00:00
|
|
|
if( GetScreen()->GetZoom() == selectedZoom )
|
2007-08-15 02:43:57 +00:00
|
|
|
return;
|
2011-01-31 18:26:12 +00:00
|
|
|
|
2011-02-05 02:21:11 +00:00
|
|
|
GetScreen()->SetZoom( selectedZoom );
|
2015-04-30 08:46:02 +00:00
|
|
|
RedrawScreen( GetScrollCenterPosition(), false );
|
|
|
|
}
|
2013-07-07 17:30:44 +00:00
|
|
|
|
2015-04-30 08:46:02 +00:00
|
|
|
// Notify GAL
|
|
|
|
TOOL_MANAGER* mgr = GetToolManager();
|
2013-07-07 17:30:44 +00:00
|
|
|
|
2015-04-30 08:46:02 +00:00
|
|
|
if( mgr && IsGalCanvasActive() )
|
2015-07-03 18:58:12 +00:00
|
|
|
{
|
2015-04-30 08:46:02 +00:00
|
|
|
mgr->RunAction( "common.Control.zoomPreset", true, id );
|
2015-07-03 18:58:12 +00:00
|
|
|
UpdateStatusBar();
|
|
|
|
}
|
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
|
|
|
{
|
2007-08-15 02:43:57 +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::DisplayUnitsMsg()
|
2007-05-06 16:03:28 +00:00
|
|
|
{
|
2007-08-15 02:43:57 +00:00
|
|
|
wxString msg;
|
|
|
|
|
2010-07-12 14:07:09 +00:00
|
|
|
switch( g_UserUnit )
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
SetStatusText( msg, 4 );
|
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
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
|
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
|
|
|
{
|
2015-05-12 09:05:36 +00:00
|
|
|
if( glistIdx < 0 || glistIdx >= (int) m_gridSelectBox->GetCount() )
|
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
|
|
|
|
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
|
|
|
{
|
2015-07-03 18:58:12 +00:00
|
|
|
KIGFX::GAL* gal = m_galCanvas->GetGAL();
|
|
|
|
KIGFX::VIEW* view = m_galCanvas->GetView();
|
|
|
|
double zoomFactor = gal->GetWorldScale() / gal->GetZoomFactor();
|
|
|
|
level = m_zoomLevelCoeff * zoomFactor * view->GetScale();
|
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();
|
2015-03-03 14:53:47 +00:00
|
|
|
|
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;
|
|
|
|
|
|
|
|
if( wtmp.SetFromWxString( aCfg->Read(
|
|
|
|
baseCfgName + GridColorEntryKeyword, wxT( "NONE" ) ) ) )
|
|
|
|
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
|
|
|
|
2017-02-15 05:32:25 +00:00
|
|
|
m_galDisplayOptions->ReadConfig( aCfg, baseCfgName + GalDisplayOptionsKeyword );
|
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
|
|
|
|
|
|
|
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 );
|
2016-04-08 12:11:05 +00:00
|
|
|
|
|
|
|
if( GetScreen() )
|
|
|
|
aCfg->Write( baseCfgName + MaxUndoItemsEntry, long( GetScreen()->GetMaxUndoItems() ) );
|
2016-12-23 15:21:00 +00:00
|
|
|
|
2017-02-15 05:32:25 +00:00
|
|
|
m_galDisplayOptions->WriteConfig( aCfg, baseCfgName + GalDisplayOptionsKeyword );
|
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;
|
|
|
|
aItem->GetMsgPanelInfo( items );
|
|
|
|
SetMsgPanel( items );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-07-03 18:58:12 +00:00
|
|
|
void EDA_DRAW_FRAME::UpdateMsgPanel()
|
|
|
|
{
|
|
|
|
EDA_ITEM* item = GetScreen()->GetCurItem();
|
|
|
|
|
|
|
|
if( item )
|
|
|
|
SetMsgPanel( item );
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2012-09-02 12:06:47 +00:00
|
|
|
wxString EDA_DRAW_FRAME::CoordinateToString( int aValue, bool aConvertToMils ) const
|
2011-03-11 15:53:28 +00:00
|
|
|
{
|
2012-04-13 18:51:24 +00:00
|
|
|
return ::CoordinateToString( aValue, aConvertToMils );
|
2011-03-11 15:53:28 +00:00
|
|
|
}
|
2012-03-26 23:47:08 +00:00
|
|
|
|
2012-09-02 12:06:47 +00:00
|
|
|
wxString EDA_DRAW_FRAME::LengthDoubleToString( double aValue, bool aConvertToMils ) const
|
2012-04-27 14:15:11 +00:00
|
|
|
{
|
|
|
|
return ::LengthDoubleToString( aValue, aConvertToMils );
|
|
|
|
}
|
|
|
|
|
2012-03-26 23:47:08 +00:00
|
|
|
|
2016-06-08 11:19:53 +00:00
|
|
|
bool EDA_DRAW_FRAME::HandleBlockBegin( wxDC* aDC, EDA_KEY aKey, const wxPoint& aPosition,
|
|
|
|
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
|
|
|
|
case BLOCK_COPY: // Copy
|
2015-03-22 09:42:41 +00:00
|
|
|
case BLOCK_COPY_AND_INCREMENT: // Copy and increment relevant references
|
2014-07-29 16:38:27 +00:00
|
|
|
case BLOCK_DELETE: // Delete
|
|
|
|
case BLOCK_SAVE: // Save
|
|
|
|
case BLOCK_ROTATE: // Rotate 90 deg
|
|
|
|
case BLOCK_FLIP: // Flip
|
|
|
|
case BLOCK_ZOOM: // Window Zoom
|
2012-03-26 23:47:08 +00:00
|
|
|
case BLOCK_MIRROR_X:
|
2014-07-29 16:38:27 +00:00
|
|
|
case BLOCK_MIRROR_Y: // mirror
|
|
|
|
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 );
|
|
|
|
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" ) );
|
|
|
|
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
|
|
|
|
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
|
2015-07-03 18:58:12 +00:00
|
|
|
double zoomFactor = gal->GetWorldScale() / gal->GetZoomFactor();
|
2015-07-02 19:25:39 +00:00
|
|
|
double zoom = 1.0 / ( zoomFactor * m_canvas->GetZoom() );
|
|
|
|
view->SetScale( zoom );
|
|
|
|
view->SetCenter( VECTOR2D( m_canvas->GetScreenCenterLogicalPosition() ) );
|
|
|
|
}
|
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
|
2015-07-15 15:32:30 +00:00
|
|
|
GetGalCanvas()->GetViewControls()->EnableCursorWarping( !m_canvas->GetEnableZoomNoCenter() );
|
2016-02-24 19:53:02 +00:00
|
|
|
GetGalCanvas()->GetViewControls()->EnableMousewheelPan( m_canvas->GetEnableMousewheelPan() );
|
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
|
2015-07-03 18:58:12 +00:00
|
|
|
double zoomFactor = gal->GetWorldScale() / gal->GetZoomFactor();
|
|
|
|
// TODO replace it with EDA_DRAW_PANEL_GAL::GetLegacyZoom
|
|
|
|
m_canvas->SetZoom( 1.0 / ( zoomFactor * view->GetScale() ) );
|
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
|
|
|
|
m_auimgr.GetPane( wxT( "DrawFrame" ) ).Show( !aEnable );
|
|
|
|
m_auimgr.GetPane( wxT( "DrawFrameGal" ) ).Show( aEnable );
|
|
|
|
m_auimgr.Update();
|
|
|
|
|
2014-07-09 13:10:32 +00:00
|
|
|
// Reset current tool on switch();
|
|
|
|
SetToolID( ID_NO_TOOL_SELECTED, wxCURSOR_DEFAULT, wxEmptyString );
|
|
|
|
|
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
|
|
|
|
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
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::RefreshCrossHair( const wxPoint &aOldPos,
|
|
|
|
const wxPoint &aEvtPos,
|
|
|
|
wxDC* aDC )
|
|
|
|
{
|
|
|
|
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
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void EDA_DRAW_FRAME::GeneralControlKeyMovement( int aHotKey, wxPoint *aPos,
|
|
|
|
bool aSnapToGrid )
|
|
|
|
{
|
|
|
|
|
|
|
|
// 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:
|
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;
|
|
|
|
}
|
|
|
|
m_canvas->MoveCursor( *aPos );
|
|
|
|
m_movingCursorWithKeyboard = true;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|