2012-01-09 17:24:01 +00:00
|
|
|
/*
|
|
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
|
2020-04-02 19:24:28 +00:00
|
|
|
* Copyright (C) 2015-2020 KiCad Developers, see change_log.txt for contributors.
|
2012-01-09 17:24:01 +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
|
|
|
|
*/
|
|
|
|
|
2012-04-13 18:51:24 +00:00
|
|
|
#include <base_units.h>
|
Modular-Kicad milestone B), major portions:
*) Rework the set language support, simplify it by using KIWAY. Now any major
frame with a "change language" menu can change the language for all KIWAY_PLAYERs
in the whole KIWAY. Multiple KIWAYs are not supported yet.
*) Simplify "modal wxFrame" support, and add that support exclusively to
KIWAY_PLAYER where it is inherited by all derivatives. The function
KIWAY_PLAYER::ShowModal() is in the vtable and so is cross module capable.
*) Remove the requirements and assumptions that the wxFrame hierarchy always
had PCB_EDIT_FRAME and SCH_EDIT_FRAME as immediate parents of their viewers
and editors. This is no longer the case, nor required.
*) Use KIWAY::Player() everywhere to make KIWAY_PLAYERs, this registers the
KIWAY_PLAYER within the KIWAY and makes it very easy to find an open frame
quickly. It also gives control to the KIWAY as to frame hierarchical
relationships.
*) Change single_top to use the KIWAY for loading a KIFACE and instantiating
the single KIWAY_PLAYER, see bullet immediately above.
*) Add KIWAY::OnKiwayEnd() and call it from PGM_BASE at program termination, this
gives the KIFACEs a chance to save their final configuration dope to disk.
*) Add dedicated FRAME_T's for the modal frames, so m_Ident can be tested and
these modal frames are distinctly different than their non-modal equivalents.
KIWAY_PLAYER::IsModal() is !not! a valid test during the wxFrame's constructor,
so this is another important reason for having a dedicated FRAME_T for each
modal wxFrame.
On balance, more lines were deleted than were added to achieve all this.
2014-05-03 17:40:19 +00:00
|
|
|
#include <kiway.h>
|
2020-02-03 16:46:58 +00:00
|
|
|
#include <pgm_base.h>
|
|
|
|
#include <eeschema_settings.h>
|
2018-08-03 12:18:26 +00:00
|
|
|
#include <sch_draw_panel.h>
|
|
|
|
#include <sch_view.h>
|
|
|
|
#include <sch_painter.h>
|
2020-02-03 16:46:58 +00:00
|
|
|
#include <settings/settings_manager.h>
|
2018-08-03 12:18:26 +00:00
|
|
|
#include <gal/graphics_abstraction_layer.h>
|
2017-10-06 18:07:43 +00:00
|
|
|
#include <confirm.h>
|
2018-09-05 22:17:22 +00:00
|
|
|
#include <preview_items/selection_area.h>
|
2017-10-06 18:07:43 +00:00
|
|
|
#include <class_library.h>
|
2017-08-12 12:09:39 +00:00
|
|
|
#include <sch_base_frame.h>
|
|
|
|
#include <symbol_lib_table.h>
|
2019-06-15 00:29:42 +00:00
|
|
|
#include <tool/action_toolbar.h>
|
2019-04-13 17:41:11 +00:00
|
|
|
#include <tool/tool_manager.h>
|
|
|
|
#include <tool/tool_dispatcher.h>
|
2019-05-10 17:19:48 +00:00
|
|
|
#include <tools/ee_actions.h>
|
2019-08-08 09:06:53 +00:00
|
|
|
#include <tools/ee_selection_tool.h>
|
2020-04-14 18:11:50 +00:00
|
|
|
#include <default_values.h> // For some default values
|
2015-04-22 11:39:00 +00:00
|
|
|
|
2019-11-06 19:15:42 +00:00
|
|
|
|
|
|
|
LIB_PART* SchGetLibPart( const LIB_ID& aLibId, SYMBOL_LIB_TABLE* aLibTable, PART_LIB* aCacheLib,
|
|
|
|
wxWindow* aParent, bool aShowErrorMsg )
|
2017-10-06 18:07:43 +00:00
|
|
|
{
|
2020-04-02 19:24:28 +00:00
|
|
|
wxCHECK_MSG( aLibTable, nullptr, "Invalid symbol library table." );
|
2017-10-06 18:07:43 +00:00
|
|
|
|
2020-04-02 19:24:28 +00:00
|
|
|
LIB_PART* symbol = nullptr;
|
2017-10-06 18:07:43 +00:00
|
|
|
|
|
|
|
try
|
|
|
|
{
|
2019-11-06 19:15:42 +00:00
|
|
|
symbol = aLibTable->LoadSymbol( aLibId );
|
2017-10-06 18:07:43 +00:00
|
|
|
|
2019-11-06 19:15:42 +00:00
|
|
|
if( !symbol && aCacheLib )
|
2020-04-02 19:24:28 +00:00
|
|
|
{
|
|
|
|
wxCHECK_MSG( aCacheLib->IsCache(), nullptr, "Invalid cache library." );
|
|
|
|
|
|
|
|
wxString cacheName = aLibId.GetLibNickname().wx_str();
|
|
|
|
cacheName += "_" + aLibId.GetLibItemName();
|
|
|
|
symbol = aCacheLib->FindPart( cacheName );
|
|
|
|
}
|
2017-10-06 18:07:43 +00:00
|
|
|
}
|
|
|
|
catch( const IO_ERROR& ioe )
|
|
|
|
{
|
|
|
|
if( aShowErrorMsg )
|
|
|
|
{
|
2019-04-17 19:09:48 +00:00
|
|
|
wxString msg = wxString::Format( _( "Error loading symbol '%s' from library '%s'." ),
|
|
|
|
aLibId.GetLibItemName().wx_str(),
|
|
|
|
aLibId.GetLibNickname().wx_str() );
|
2017-10-06 18:07:43 +00:00
|
|
|
DisplayErrorMessage( aParent, msg, ioe.What() );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-06 19:15:42 +00:00
|
|
|
return symbol;
|
2017-10-06 18:07:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-04-17 19:09:48 +00:00
|
|
|
SCH_BASE_FRAME::SCH_BASE_FRAME( KIWAY* aKiway, wxWindow* aParent, FRAME_T aWindowType,
|
|
|
|
const wxString& aTitle, const wxPoint& aPosition,
|
|
|
|
const wxSize& aSize, long aStyle, const wxString& aFrameName ) :
|
2020-04-04 20:32:14 +00:00
|
|
|
EDA_DRAW_FRAME( aKiway, aParent, aWindowType, aTitle, aPosition, aSize, aStyle, aFrameName ),
|
2020-04-12 17:50:33 +00:00
|
|
|
m_defaultLineWidth( DEFAULT_LINE_THICKNESS * IU_PER_MILS ),
|
|
|
|
m_defaultWireThickness( DEFAULT_WIRE_THICKNESS * IU_PER_MILS ),
|
|
|
|
m_defaultBusThickness( DEFAULT_BUS_THICKNESS * IU_PER_MILS ),
|
2020-04-14 18:11:50 +00:00
|
|
|
m_defaultTextSize( DEFAULT_TEXT_SIZE * IU_PER_MILS ),
|
2020-04-14 12:25:00 +00:00
|
|
|
m_textOffsetRatio( 0.08 ),
|
2020-05-03 23:55:31 +00:00
|
|
|
m_pinSymbolSize( DEFAULT_TEXT_SIZE * IU_PER_MILS / 2 ),
|
2020-04-12 23:09:17 +00:00
|
|
|
m_showPinElectricalTypeName( false )
|
2012-02-19 19:53:11 +00:00
|
|
|
{
|
2018-09-10 13:37:28 +00:00
|
|
|
createCanvas();
|
|
|
|
|
2020-04-04 20:32:14 +00:00
|
|
|
// Adjusted to display zoom level ~ 1 when the screen shows a 1:1 image
|
|
|
|
// Obviously depends on the monitor, but this is an acceptable value
|
|
|
|
m_zoomLevelCoeff = 11.0 * IU_PER_MILS;
|
2012-02-19 19:53:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-08-12 12:09:39 +00:00
|
|
|
SCH_BASE_FRAME::~SCH_BASE_FRAME()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-01-09 17:24:01 +00:00
|
|
|
SCH_SCREEN* SCH_BASE_FRAME::GetScreen() const
|
|
|
|
{
|
|
|
|
return (SCH_SCREEN*) EDA_DRAW_FRAME::GetScreen();
|
|
|
|
}
|
|
|
|
|
2017-10-06 18:07:43 +00:00
|
|
|
|
2019-04-17 19:09:48 +00:00
|
|
|
void SCH_BASE_FRAME::SetScreen( BASE_SCREEN* aScreen )
|
|
|
|
{
|
|
|
|
EDA_DRAW_FRAME::SetScreen( aScreen );
|
|
|
|
|
|
|
|
if( m_toolManager )
|
|
|
|
{
|
2019-05-03 10:16:39 +00:00
|
|
|
m_toolManager->SetEnvironment( aScreen, GetCanvas()->GetView(),
|
2019-04-17 19:09:48 +00:00
|
|
|
GetCanvas()->GetViewControls(), this );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-01-06 07:38:58 +00:00
|
|
|
const wxString SCH_BASE_FRAME::GetZoomLevelIndicator() const
|
|
|
|
{
|
|
|
|
return EDA_DRAW_FRAME::GetZoomLevelIndicator();
|
|
|
|
}
|
2012-01-09 17:24:01 +00:00
|
|
|
|
2017-10-06 18:07:43 +00:00
|
|
|
|
2020-04-04 20:32:14 +00:00
|
|
|
void SCH_BASE_FRAME::SetDefaultLineWidth( int aWidth )
|
|
|
|
{
|
|
|
|
m_defaultLineWidth = aWidth;
|
2020-04-14 12:25:00 +00:00
|
|
|
GetRenderSettings()->SetDefaultPenWidth( aWidth );
|
2020-04-04 20:32:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void SCH_BASE_FRAME::SetDefaultWireThickness( int aThickness )
|
|
|
|
{
|
|
|
|
m_defaultWireThickness = aThickness;
|
|
|
|
GetRenderSettings()->m_DefaultWireThickness = aThickness;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void SCH_BASE_FRAME::SetDefaultBusThickness( int aThickness )
|
|
|
|
{
|
|
|
|
m_defaultBusThickness = aThickness;
|
|
|
|
GetRenderSettings()->m_DefaultBusThickness = aThickness;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-05-03 23:55:31 +00:00
|
|
|
void SCH_BASE_FRAME::SetPinSymbolSize( int aSize )
|
|
|
|
{
|
|
|
|
m_pinSymbolSize = aSize;
|
|
|
|
GetRenderSettings()->m_PinSymbolSize = aSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-01-09 17:24:01 +00:00
|
|
|
void SCH_BASE_FRAME::SetPageSettings( const PAGE_INFO& aPageSettings )
|
|
|
|
{
|
|
|
|
GetScreen()->SetPageSettings( aPageSettings );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const PAGE_INFO& SCH_BASE_FRAME::GetPageSettings () const
|
|
|
|
{
|
|
|
|
return GetScreen()->GetPageSettings();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const wxSize SCH_BASE_FRAME::GetPageSizeIU() const
|
|
|
|
{
|
|
|
|
// GetSizeIU is compile time dependent:
|
|
|
|
return GetScreen()->GetPageSettings().GetSizeIU();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-03 05:15:23 +00:00
|
|
|
const wxPoint& SCH_BASE_FRAME::GetAuxOrigin() const
|
2012-01-09 17:24:01 +00:00
|
|
|
{
|
|
|
|
wxASSERT( GetScreen() );
|
2013-08-03 05:15:23 +00:00
|
|
|
return GetScreen()->GetAuxOrigin();
|
2012-01-09 17:24:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-03 05:15:23 +00:00
|
|
|
void SCH_BASE_FRAME::SetAuxOrigin( const wxPoint& aPosition )
|
2012-01-09 17:24:01 +00:00
|
|
|
{
|
|
|
|
wxASSERT( GetScreen() );
|
2013-08-03 05:15:23 +00:00
|
|
|
GetScreen()->SetAuxOrigin( aPosition );
|
2012-01-09 17:24:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const TITLE_BLOCK& SCH_BASE_FRAME::GetTitleBlock() const
|
|
|
|
{
|
|
|
|
wxASSERT( GetScreen() );
|
|
|
|
return GetScreen()->GetTitleBlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void SCH_BASE_FRAME::SetTitleBlock( const TITLE_BLOCK& aTitleBlock )
|
|
|
|
{
|
|
|
|
wxASSERT( GetScreen() );
|
|
|
|
GetScreen()->SetTitleBlock( aTitleBlock );
|
|
|
|
}
|
2012-04-13 18:51:24 +00:00
|
|
|
|
|
|
|
|
|
|
|
void SCH_BASE_FRAME::UpdateStatusBar()
|
|
|
|
{
|
|
|
|
wxString line;
|
|
|
|
BASE_SCREEN* screen = GetScreen();
|
|
|
|
|
|
|
|
if( !screen )
|
|
|
|
return;
|
|
|
|
|
|
|
|
EDA_DRAW_FRAME::UpdateStatusBar();
|
|
|
|
|
|
|
|
// Display absolute coordinates:
|
2019-06-13 17:28:55 +00:00
|
|
|
VECTOR2D cursorPos = GetCanvas()->GetViewControls()->GetCursorPosition();
|
2019-06-13 13:34:38 +00:00
|
|
|
double dXpos = To_User_Unit( GetUserUnits(), cursorPos.x );
|
|
|
|
double dYpos = To_User_Unit( GetUserUnits(), cursorPos.y );
|
2012-04-13 18:51:24 +00:00
|
|
|
|
|
|
|
wxString absformatter;
|
|
|
|
wxString locformatter;
|
|
|
|
|
2018-02-02 15:56:09 +00:00
|
|
|
switch( GetUserUnits() )
|
2012-04-13 18:51:24 +00:00
|
|
|
{
|
2019-12-20 14:11:39 +00:00
|
|
|
case EDA_UNITS::INCHES:
|
2019-02-14 09:55:57 +00:00
|
|
|
absformatter = "X %.3f Y %.3f";
|
|
|
|
locformatter = "dx %.3f dy %.3f dist %.3f";
|
2012-04-13 18:51:24 +00:00
|
|
|
break;
|
|
|
|
|
2019-12-20 14:11:39 +00:00
|
|
|
case EDA_UNITS::MILLIMETRES:
|
2020-02-13 13:39:52 +00:00
|
|
|
absformatter = "X %.4f Y %.4f";
|
|
|
|
locformatter = "dx %.4f dy %.4f dist %.4f";
|
2012-04-13 18:51:24 +00:00
|
|
|
break;
|
|
|
|
|
2019-12-20 14:11:39 +00:00
|
|
|
case EDA_UNITS::UNSCALED:
|
2019-02-14 09:55:57 +00:00
|
|
|
absformatter = "X %f Y %f";
|
|
|
|
locformatter = "dx %f dy %f dist %f";
|
2012-04-13 18:51:24 +00:00
|
|
|
break;
|
2015-02-19 15:03:45 +00:00
|
|
|
|
2019-06-29 16:46:25 +00:00
|
|
|
default:
|
2015-02-19 15:03:45 +00:00
|
|
|
wxASSERT( false );
|
|
|
|
break;
|
2012-04-13 18:51:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
line.Printf( absformatter, dXpos, dYpos );
|
|
|
|
SetStatusText( line, 2 );
|
|
|
|
|
|
|
|
// Display relative coordinates:
|
2019-06-13 13:34:38 +00:00
|
|
|
double dx = cursorPos.x - screen->m_LocalOrigin.x;
|
|
|
|
double dy = cursorPos.y - screen->m_LocalOrigin.y;
|
2013-08-03 05:15:23 +00:00
|
|
|
|
2018-02-02 15:56:09 +00:00
|
|
|
dXpos = To_User_Unit( GetUserUnits(), dx );
|
|
|
|
dYpos = To_User_Unit( GetUserUnits(), dy );
|
2012-04-13 18:51:24 +00:00
|
|
|
|
|
|
|
// We already decided the formatter above
|
2013-05-01 17:32:36 +00:00
|
|
|
line.Printf( locformatter, dXpos, dYpos, hypot( dXpos, dYpos ) );
|
2012-04-13 18:51:24 +00:00
|
|
|
SetStatusText( line, 3 );
|
|
|
|
|
2019-05-24 13:55:33 +00:00
|
|
|
// refresh grid display
|
|
|
|
DisplayGridMsg();
|
|
|
|
|
2012-04-13 18:51:24 +00:00
|
|
|
// refresh units display
|
|
|
|
DisplayUnitsMsg();
|
|
|
|
}
|
2017-08-12 12:09:39 +00:00
|
|
|
|
|
|
|
|
2017-10-06 18:07:43 +00:00
|
|
|
LIB_PART* SCH_BASE_FRAME::GetLibPart( const LIB_ID& aLibId, bool aUseCacheLib, bool aShowErrorMsg )
|
|
|
|
{
|
|
|
|
PART_LIB* cache = ( aUseCacheLib ) ? Prj().SchLibs()->GetCacheLibrary() : NULL;
|
|
|
|
|
|
|
|
return SchGetLibPart( aLibId, Prj().SchSymbolLibTable(), cache, this, aShowErrorMsg );
|
|
|
|
}
|
2017-11-13 10:53:19 +00:00
|
|
|
|
|
|
|
|
|
|
|
bool SCH_BASE_FRAME::saveSymbolLibTables( bool aGlobal, bool aProject )
|
|
|
|
{
|
2018-08-06 18:33:28 +00:00
|
|
|
wxString msg;
|
2017-11-13 10:53:19 +00:00
|
|
|
bool success = true;
|
|
|
|
|
|
|
|
if( aGlobal )
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
2018-08-06 18:33:28 +00:00
|
|
|
SYMBOL_LIB_TABLE::GetGlobalLibTable().Save( SYMBOL_LIB_TABLE::GetGlobalTableFileName() );
|
2017-11-13 10:53:19 +00:00
|
|
|
}
|
|
|
|
catch( const IO_ERROR& ioe )
|
|
|
|
{
|
|
|
|
success = false;
|
2019-04-17 19:09:48 +00:00
|
|
|
msg.Printf( _( "Error saving global symbol library table:\n%s" ), ioe.What() );
|
2017-11-13 10:53:19 +00:00
|
|
|
wxMessageBox( msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if( aProject && !Prj().GetProjectName().IsEmpty() )
|
|
|
|
{
|
|
|
|
wxFileName fn( Prj().GetProjectPath(), SYMBOL_LIB_TABLE::GetSymbolLibTableFileName() );
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
Prj().SchSymbolLibTable()->Save( fn.GetFullPath() );
|
|
|
|
}
|
|
|
|
catch( const IO_ERROR& ioe )
|
|
|
|
{
|
|
|
|
success = false;
|
2019-04-17 19:09:48 +00:00
|
|
|
msg.Printf( _( "Error saving project-specific symbol library table:\n%s" ), ioe.What() );
|
2017-11-13 10:53:19 +00:00
|
|
|
wxMessageBox( msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return success;
|
|
|
|
}
|
2018-08-03 12:18:26 +00:00
|
|
|
|
2018-09-08 20:57:56 +00:00
|
|
|
|
2018-08-03 12:18:26 +00:00
|
|
|
void SCH_BASE_FRAME::RedrawScreen( const wxPoint& aCenterPoint, bool aWarpPointer )
|
|
|
|
{
|
2018-09-03 13:58:47 +00:00
|
|
|
KIGFX::GAL* gal = GetCanvas()->GetGAL();
|
|
|
|
|
|
|
|
double selectedZoom = GetScreen()->GetZoom();
|
|
|
|
double zoomFactor = gal->GetWorldScale() / gal->GetZoomFactor();
|
|
|
|
double scale = 1.0 / ( zoomFactor * selectedZoom );
|
|
|
|
|
|
|
|
if( aCenterPoint != wxPoint( 0, 0 ) )
|
|
|
|
GetCanvas()->GetView()->SetScale( scale, aCenterPoint );
|
|
|
|
else
|
|
|
|
GetCanvas()->GetView()->SetScale( scale );
|
|
|
|
|
2019-03-11 21:32:05 +00:00
|
|
|
GetCanvas()->GetView()->SetCenter( aCenterPoint );
|
|
|
|
|
2018-09-03 13:58:47 +00:00
|
|
|
if( aWarpPointer )
|
2018-09-14 08:15:10 +00:00
|
|
|
GetCanvas()->GetViewControls()->CenterOnCursor();
|
2018-09-03 13:58:47 +00:00
|
|
|
|
|
|
|
GetCanvas()->Refresh();
|
2018-08-03 12:18:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-09-08 20:57:56 +00:00
|
|
|
void SCH_BASE_FRAME::CenterScreen( const wxPoint& aCenterPoint, bool aWarpPointer )
|
|
|
|
{
|
|
|
|
GetCanvas()->GetView()->SetCenter( aCenterPoint );
|
|
|
|
|
|
|
|
if( aWarpPointer )
|
2018-11-12 22:09:03 +00:00
|
|
|
GetCanvas()->GetViewControls()->WarpCursor( aCenterPoint, true );
|
2018-09-08 20:57:56 +00:00
|
|
|
|
2019-06-13 17:28:55 +00:00
|
|
|
GetCanvas()->Refresh();
|
2018-09-08 20:57:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-03-16 11:05:01 +00:00
|
|
|
void SCH_BASE_FRAME::FocusOnItem( SCH_ITEM* aItem )
|
|
|
|
{
|
|
|
|
static KIID lastBrightenedItemID( niluuid );
|
|
|
|
|
|
|
|
SCH_SHEET_LIST sheetList( g_RootSheet );
|
|
|
|
SCH_SHEET_PATH dummy;
|
|
|
|
SCH_ITEM* lastItem = sheetList.GetItem( lastBrightenedItemID, &dummy );
|
|
|
|
|
|
|
|
if( lastItem && lastItem != aItem )
|
|
|
|
{
|
|
|
|
lastItem->ClearBrightened();
|
|
|
|
|
|
|
|
RefreshItem( lastItem );
|
|
|
|
lastBrightenedItemID = niluuid;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( aItem )
|
|
|
|
{
|
|
|
|
aItem->SetBrightened();
|
|
|
|
|
|
|
|
RefreshItem( aItem );
|
|
|
|
lastBrightenedItemID = aItem->m_Uuid;
|
|
|
|
|
2020-04-27 16:22:42 +00:00
|
|
|
// JEY TODO: test this with pins and fields (and with rotated symbols) ....
|
|
|
|
FocusOnLocation( aItem->GetFocusPosition() );
|
2020-03-16 11:05:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-09-05 22:17:22 +00:00
|
|
|
void SCH_BASE_FRAME::HardRedraw()
|
|
|
|
{
|
2019-06-13 17:28:55 +00:00
|
|
|
GetCanvas()->GetView()->UpdateAllItems( KIGFX::ALL );
|
|
|
|
GetCanvas()->ForceRefresh();
|
2018-09-05 22:17:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-09-02 20:19:22 +00:00
|
|
|
SCH_DRAW_PANEL* SCH_BASE_FRAME::GetCanvas() const
|
2018-08-03 12:18:26 +00:00
|
|
|
{
|
2019-06-13 17:28:55 +00:00
|
|
|
return static_cast<SCH_DRAW_PANEL*>( EDA_DRAW_FRAME::GetCanvas() );
|
2018-09-02 20:19:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
KIGFX::SCH_RENDER_SETTINGS* SCH_BASE_FRAME::GetRenderSettings()
|
|
|
|
{
|
2019-06-13 17:28:55 +00:00
|
|
|
KIGFX::PAINTER* painter = GetCanvas()->GetView()->GetPainter();
|
2018-09-02 20:19:22 +00:00
|
|
|
return static_cast<KIGFX::SCH_RENDER_SETTINGS*>( painter->GetSettings() );
|
2018-08-03 12:18:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-09-10 13:37:28 +00:00
|
|
|
void SCH_BASE_FRAME::createCanvas()
|
2018-08-03 12:18:26 +00:00
|
|
|
{
|
2018-09-15 07:00:13 +00:00
|
|
|
m_canvasType = LoadCanvasTypeSetting();
|
2018-09-10 13:37:28 +00:00
|
|
|
|
|
|
|
// Allows only a CAIRO or OPENGL canvas:
|
2019-04-17 19:09:48 +00:00
|
|
|
if( m_canvasType != EDA_DRAW_PANEL_GAL::GAL_TYPE_OPENGL
|
|
|
|
&& m_canvasType != EDA_DRAW_PANEL_GAL::GAL_TYPE_CAIRO )
|
|
|
|
{
|
2018-09-15 07:00:13 +00:00
|
|
|
m_canvasType = EDA_DRAW_PANEL_GAL::GAL_TYPE_OPENGL;
|
2019-04-17 19:09:48 +00:00
|
|
|
}
|
2018-09-10 13:37:28 +00:00
|
|
|
|
2019-06-13 17:28:55 +00:00
|
|
|
SetCanvas( new SCH_DRAW_PANEL( this, wxID_ANY, wxPoint( 0, 0 ), m_FrameSize,
|
|
|
|
GetGalDisplayOptions(), m_canvasType ));
|
2019-05-30 12:25:08 +00:00
|
|
|
ActivateGalCanvas();
|
2018-08-03 12:18:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-06 15:30:29 +00:00
|
|
|
void SCH_BASE_FRAME::RefreshItem( EDA_ITEM* aItem, bool isAddOrDelete )
|
2018-09-10 10:58:50 +00:00
|
|
|
{
|
|
|
|
EDA_ITEM* parent = aItem->GetParent();
|
|
|
|
|
|
|
|
if( aItem->Type() == SCH_SHEET_PIN_T )
|
|
|
|
{
|
|
|
|
// Sheet pins aren't in the view. Refresh their parent.
|
|
|
|
if( parent )
|
|
|
|
GetCanvas()->GetView()->Update( parent );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if( !isAddOrDelete )
|
|
|
|
GetCanvas()->GetView()->Update( aItem );
|
|
|
|
|
|
|
|
// Component children are drawn from their parents. Mark them for re-paint.
|
|
|
|
if( parent && parent->Type() == SCH_COMPONENT_T )
|
|
|
|
GetCanvas()->GetView()->Update( parent, KIGFX::REPAINT );
|
2020-03-12 13:56:44 +00:00
|
|
|
else if( parent && parent->Type() == SCH_SHEET_T )
|
|
|
|
GetCanvas()->GetView()->Update( parent, KIGFX::REPAINT );
|
2018-09-10 10:58:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GetCanvas()->Refresh();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-08-08 09:06:53 +00:00
|
|
|
void SCH_BASE_FRAME::RefreshSelection()
|
|
|
|
{
|
|
|
|
if( m_toolManager )
|
|
|
|
{
|
|
|
|
EE_SELECTION_TOOL* selectionTool = m_toolManager->GetTool<EE_SELECTION_TOOL>();
|
|
|
|
SELECTION& selection = selectionTool->GetSelection();
|
|
|
|
KIGFX::SCH_VIEW* view = GetCanvas()->GetView();
|
|
|
|
|
|
|
|
for( EDA_ITEM* item : selection )
|
2019-12-10 12:07:11 +00:00
|
|
|
{
|
|
|
|
EDA_ITEM* parent = item->GetParent();
|
|
|
|
|
|
|
|
if( item->Type() == SCH_SHEET_PIN_T )
|
|
|
|
{
|
|
|
|
// Sheet pins aren't in the view. Refresh their parent.
|
|
|
|
if( parent )
|
|
|
|
GetCanvas()->GetView()->Update( parent );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
view->Update( item, KIGFX::REPAINT );
|
|
|
|
|
|
|
|
// Component children are drawn from their parents. Mark them for re-paint.
|
|
|
|
if( parent && parent->Type() == SCH_COMPONENT_T )
|
|
|
|
GetCanvas()->GetView()->Update( parent, KIGFX::REPAINT );
|
|
|
|
}
|
|
|
|
}
|
2019-08-08 09:06:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-06 15:30:29 +00:00
|
|
|
void SCH_BASE_FRAME::AddToScreen( EDA_ITEM* aItem, SCH_SCREEN* aScreen )
|
2018-08-03 12:18:26 +00:00
|
|
|
{
|
2019-03-11 21:32:05 +00:00
|
|
|
auto screen = aScreen;
|
|
|
|
|
|
|
|
if( aScreen == nullptr )
|
|
|
|
screen = GetScreen();
|
|
|
|
|
2019-05-06 15:30:29 +00:00
|
|
|
screen->Append( (SCH_ITEM*) aItem );
|
2019-03-11 21:32:05 +00:00
|
|
|
|
|
|
|
if( screen == GetScreen() )
|
|
|
|
{
|
|
|
|
GetCanvas()->GetView()->Add( aItem );
|
|
|
|
RefreshItem( aItem, true ); // handle any additional parent semantics
|
|
|
|
}
|
2018-08-03 12:18:26 +00:00
|
|
|
}
|
|
|
|
|
2018-09-08 18:07:41 +00:00
|
|
|
|
2019-05-06 15:30:29 +00:00
|
|
|
void SCH_BASE_FRAME::RemoveFromScreen( EDA_ITEM* aItem, SCH_SCREEN* aScreen )
|
2018-08-03 12:18:26 +00:00
|
|
|
{
|
2019-03-11 21:32:05 +00:00
|
|
|
auto screen = aScreen;
|
|
|
|
|
|
|
|
if( aScreen == nullptr )
|
|
|
|
screen = GetScreen();
|
|
|
|
|
|
|
|
if( screen == GetScreen() )
|
|
|
|
GetCanvas()->GetView()->Remove( aItem );
|
|
|
|
|
2019-05-06 15:30:29 +00:00
|
|
|
screen->Remove( (SCH_ITEM*) aItem );
|
2019-03-11 21:32:05 +00:00
|
|
|
|
|
|
|
if( screen == GetScreen() )
|
|
|
|
RefreshItem( aItem, true ); // handle any additional parent semantics
|
2018-08-03 12:18:26 +00:00
|
|
|
}
|
|
|
|
|
2018-09-08 18:07:41 +00:00
|
|
|
|
2018-08-03 12:18:26 +00:00
|
|
|
void SCH_BASE_FRAME::SyncView()
|
|
|
|
{
|
2019-06-13 17:28:55 +00:00
|
|
|
auto gs = GetScreen()->GetGridSize();
|
|
|
|
GetCanvas()->GetGAL()->SetGridSize( VECTOR2D( gs.x, gs.y ));
|
|
|
|
GetCanvas()->GetView()->UpdateAllItems( KIGFX::ALL );
|
2018-08-03 12:18:26 +00:00
|
|
|
}
|
2019-06-15 00:29:42 +00:00
|
|
|
|
|
|
|
|
2020-02-03 16:46:58 +00:00
|
|
|
COLOR4D SCH_BASE_FRAME::GetLayerColor( SCH_LAYER_ID aLayer )
|
|
|
|
{
|
|
|
|
return GetColorSettings()->GetColor( aLayer );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-04-09 16:15:57 +00:00
|
|
|
void SCH_BASE_FRAME::CommonSettingsChanged( bool aEnvVarsChanged )
|
|
|
|
{
|
|
|
|
EDA_DRAW_FRAME::CommonSettingsChanged( aEnvVarsChanged );
|
|
|
|
|
|
|
|
EESCHEMA_SETTINGS* cfg = Pgm().GetSettingsManager().GetAppSettings<EESCHEMA_SETTINGS>();
|
|
|
|
m_colorSettings = Pgm().GetSettingsManager().GetColorSettings( cfg->m_ColorTheme );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-02-03 16:46:58 +00:00
|
|
|
COLOR_SETTINGS* SCH_BASE_FRAME::GetColorSettings()
|
|
|
|
{
|
|
|
|
if( !m_colorSettings )
|
|
|
|
{
|
2020-04-09 16:15:57 +00:00
|
|
|
EESCHEMA_SETTINGS* cfg = Pgm().GetSettingsManager().GetAppSettings<EESCHEMA_SETTINGS>();
|
2020-02-03 16:46:58 +00:00
|
|
|
m_colorSettings = Pgm().GetSettingsManager().GetColorSettings( cfg->m_ColorTheme );
|
|
|
|
}
|
|
|
|
|
|
|
|
return m_colorSettings;
|
2020-04-02 19:24:28 +00:00
|
|
|
}
|