kicad/include/eda_base_frame.h

807 lines
27 KiB
C
Raw Normal View History

/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2009-2015 Jean-Pierre Charras, jp.charras wanadoo.fr
* Copyright (C) 2011 Wayne Stambaugh <stambaughw@gmail.com>
2020-12-18 14:04:03 +00:00
* Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
*
* 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
*/
/**
* @file eda_base_frame.h
* @brief Base window classes and related definitions.
*/
2019-12-19 14:22:42 +00:00
#ifndef EDA_BASE_FRAME_H_
#define EDA_BASE_FRAME_H_
#include <vector>
#include <wx/socket.h>
#include <wx/log.h>
#include <wx/wxhtml.h>
#include <wx/laywin.h>
2009-11-02 22:24:55 +00:00
#include <wx/aui/aui.h>
#include <wx/docview.h>
#include <wx/event.h>
#include <layers_id_colors_and_visibility.h>
#include <frame_type.h>
2019-06-09 21:57:23 +00:00
#include <hotkeys_basic.h>
#include <kiway_holder.h>
#include <tool/tools_holder.h>
#include <widgets/ui_common.h>
#include <undo_redo_container.h>
2020-10-24 14:45:37 +00:00
#include <eda_units.h>
2007-10-10 18:01:14 +00:00
// Option for main frames
#define KICAD_DEFAULT_DRAWFRAME_STYLE wxDEFAULT_FRAME_STYLE | wxWANTS_CHARS
#define KICAD_MANAGER_FRAME_NAME wxT( "KicadFrame" )
class EDA_ITEM;
class EDA_RECT;
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
class EDA_DRAW_PANEL_GAL;
class EDA_MSG_PANEL;
class BASE_SCREEN;
class PARAM_CFG;
class PAGE_INFO;
class PLOTTER;
class TITLE_BLOCK;
class MSG_PANEL_ITEM;
class TOOL_MANAGER;
class TOOL_DISPATCHER;
class ACTIONS;
class PAGED_DIALOG;
class DIALOG_EDIT_LIBRARY_TABLES;
2019-06-09 21:57:23 +00:00
class PANEL_HOTKEYS_EDITOR;
class FILE_HISTORY;
class SETTINGS_MANAGER;
2020-10-24 14:45:37 +00:00
class SEARCH_STACK;
class APP_SETTINGS_BASE;
class WX_INFOBAR;
struct WINDOW_SETTINGS;
struct WINDOW_STATE;
#define DEFAULT_MAX_UNDO_ITEMS 0
#define ABS_MAX_UNDO_ITEMS (INT_MAX / 2)
/// This is the handler functor for the update UI events
typedef std::function< void( wxUpdateUIEvent& ) > UIUpdateHandler;
wxDECLARE_EVENT( UNITS_CHANGED, wxCommandEvent );
* 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
/**
* The base frame for deriving all KiCad main window classes.
*
* This class is not intended to be used directly. It provides support for automatic calls
* to SaveSettings() function. SaveSettings() for a derived class can choose to do nothing,
* or rely on basic SaveSettings() support in this base class to do most of the work by
2020-12-18 14:04:03 +00:00
* calling it from the derived class's SaveSettings(). This class is not a #KIWAY_PLAYER
* because #KICAD_MANAGER_FRAME is derived from it and that class is not a player.
*/
class EDA_BASE_FRAME : public wxFrame, public TOOLS_HOLDER, public KIWAY_HOLDER
{
public:
2020-12-18 14:04:03 +00:00
EDA_BASE_FRAME( wxWindow* aParent, FRAME_T aFrameType, const wxString& aTitle,
const wxPoint& aPos, const wxSize& aSize, long aStyle,
const wxString& aFrameName, KIWAY* aKiway );
~EDA_BASE_FRAME();
/**
* Return the user units currently in use.
*/
2019-12-20 14:11:39 +00:00
EDA_UNITS GetUserUnits() const
{
return m_userUnits;
}
void SetUserUnits( EDA_UNITS aUnits )
{
m_userUnits = aUnits;
}
void ChangeUserUnits( EDA_UNITS aUnits );
virtual void ToggleUserUnits() { }
SETTINGS_MANAGER* GetSettingsManager() const { return m_settingsManager; }
virtual SEVERITY GetSeverity( int aErrorCode ) const { return RPT_SEVERITY_UNDEFINED; }
/**
* Override the default process event handler to implement the auto save feature.
*
* @warning If you override this function in a derived class, make sure you call down to
* this or the auto save feature will be disabled.
*/
2016-09-24 18:53:15 +00:00
bool ProcessEvent( wxEvent& aEvent ) override;
/**
* Capture the key event before it is sent to the GUI.
*
* The basic frame does not capture this event. Editor frames should override this event
* function to capture and filter these keys when they are used as hotkeys, and skip it if
* the key is not used as hotkey (otherwise the key events will be not sent to menus).
*/
virtual void OnCharHook( wxKeyEvent& event );
/**
2020-12-18 14:04:03 +00:00
* The #TOOL_DISPATCHER needs these to work around some issues in wxWidgets where the menu
* events aren't captured by the menus themselves.
*/
void OnMenuEvent( wxMenuEvent& event );
/**
* Register a UI update handler for the control with ID @c aID
*
* @param aID is the control ID to register the handler for
* @param aConditions are the UI conditions to use for the control states
*/
virtual void RegisterUIUpdateHandler( int aID, const ACTION_CONDITIONS& aConditions ) override;
/**
* Unregister a UI handler for a given ID that was registered using @c RegisterUIUpdateHandler
*
* @param aID is the control ID to unregister the handler for
*/
virtual void UnregisterUIUpdateHandler( int aID ) override;
/**
2020-12-18 14:04:03 +00:00
* Handle events generated when the UI is trying to figure out the current state of the
* UI controls related to #TOOL_ACTIONS (e.g. enabled, checked, etc.).
*
* @param aEvent is the wxUpdateUIEvent to be processed.
* @param aFrame is the frame to get the selection from
2020-12-18 14:04:03 +00:00
* @param aCond are the #UI SELECTION_CONDITIONS used
*/
static void HandleUpdateUIEvent( wxUpdateUIEvent& aEvent, EDA_BASE_FRAME* aFrame,
ACTION_CONDITIONS aCond );
virtual void OnMove( wxMoveEvent& aEvent )
{
aEvent.Skip();
}
void OnMaximize( wxMaximizeEvent& aEvent );
void SetAutoSaveInterval( int aInterval );
int GetAutoSaveInterval() const { return m_autoSaveInterval; }
2020-11-16 11:16:44 +00:00
bool IsType( FRAME_T aType ) const { return m_ident == aType; }
2019-06-09 21:57:23 +00:00
/**
2020-12-18 14:04:03 +00:00
* Return a #SEARCH_STACK pertaining to entire program.
2019-06-09 21:57:23 +00:00
*
* This is overloaded in #KICAD_MANAGER_FRAME
*/
virtual const SEARCH_STACK& sys_search();
2019-06-09 21:57:23 +00:00
virtual wxString help_name();
2019-06-09 21:57:23 +00:00
void OnKicadAbout( wxCommandEvent& event );
void OnPreferences( wxCommandEvent& event );
void PrintMsg( const wxString& text );
void CreateInfoBar();
void FinishAUIInitialization();
/**
2020-12-18 14:04:03 +00:00
* @return the #WX_INFOBAR that can be displayed on the top of the canvas.
*/
WX_INFOBAR* GetInfoBar() { return m_infoBar; }
/**
* Show the #WX_INFOBAR displayed on the top of the canvas with a message and an error
* icon on the left of the infobar, and an optional closebox to the right.
2020-12-18 14:04:03 +00:00
*
* The infobar will be closed after a timeout.
*
* @param aErrorMsg is the message to display.
2020-12-18 14:04:03 +00:00
* @param aShowCloseButton true to show a close button on the right of the #WX_INFOBAR.
*/
void ShowInfoBarError( const wxString& aErrorMsg, bool aShowCloseButton = false );
/**
* Show the #WX_INFOBAR displayed on the top of the canvas with a message and an error
* icon on the left of the infobar, and an optional closebox to the right.
*
* The infobar will be closed after a timeout.
*
* This version accepts a callback which will be called when the infobar is dismissed
* (either as a result of user action or a timeout). This can be useful when the caller
* wants to make other decorations in the canvas to highlight the error.
*
* @param aErrorMsg is the message to display.
* @param aShowCloseButton true to show a close button on the right of the #WX_INFOBAR.
* @param aCallback a callback to be called when the infobar is dismissed.
*/
void ShowInfoBarError( const wxString& aErrorMsg, bool aShowCloseButton,
std::function<void(void)> aCallback );
/**
2020-12-18 14:04:03 +00:00
* Show the #WX_INFOBAR displayed on the top of the canvas with a message and a warning
* icon on the left of the infobar.
*
* The infobar will be closed after a timeout.
*
* @param aErrorMsg is the message to display.
* @param aShowCloseButton true to show a close button on the right of the #WX_INFOBAR.
*/
void ShowInfoBarWarning( const wxString& aWarningMsg, bool aShowCloseButton = false );
/**
2020-12-18 14:04:03 +00:00
* Show the #WX_INFOBAR displayed on the top of the canvas with a message and an info
* icon on the left of the infobar.
*
* The infobar will be closed after a timeout.
*
* @param aErrorMsg is the message to display.
* @param aShowCloseButton true to show a close button on the right of the #WX_INFOBAR.
*/
void ShowInfoBarMsg( const wxString& aMsg, bool aShowCloseButton = false );
/**
* Returns the settings object used in SaveSettings(), and is overloaded in
2020-12-18 14:04:03 +00:00
* #KICAD_MANAGER_FRAME.
*/
virtual APP_SETTINGS_BASE* config() const;
/**
* Allow a frame to load its preference panels (if any) into the preferences dialog.
2020-12-18 14:04:03 +00:00
*
* @param aParent a paged dialog into which the preference panels should be installed.
*/
2019-06-09 21:57:23 +00:00
virtual void InstallPreferences( PAGED_DIALOG* , PANEL_HOTKEYS_EDITOR* ) { }
void LoadWindowState( const wxString& aFileName );
/**
2020-12-18 14:04:03 +00:00
* Load window settings from the given settings object.
*
* Normally called by #LoadSettings() unless the window in question is a child window
* that* stores its settings somewhere other than #APP_SETTINGS_BASE::m_Window.
*/
void LoadWindowSettings( const WINDOW_SETTINGS* aCfg );
/**
2020-12-18 14:04:03 +00:00
* Save window settings to the given settings object.
*
* Normally called by #SaveSettings unless the window in question is a child window that
* stores its settings somewhere other than #APP_SETTINGS_BASE::m_Window.
*/
void SaveWindowSettings( WINDOW_SETTINGS* aCfg );
/**
* Load common frame parameters from a configuration file.
*
2020-12-18 14:04:03 +00:00
* Don't forget to call the base method or your frames won't remember their positions
* and sizes.
*/
virtual void LoadSettings( APP_SETTINGS_BASE* aCfg );
/**
2020-12-18 14:04:03 +00:00
* Save common frame parameters to a configuration data file.
*
2020-12-18 14:04:03 +00:00
* Don't forget to call the base class's SaveSettings() from your derived
* #SaveSettings() otherwise the frames won't remember their positions and sizes.
*/
virtual void SaveSettings( APP_SETTINGS_BASE* aCfg );
/**
2020-12-18 14:04:03 +00:00
* Return a pointer to the window settings for this frame.
*
* By default, points to aCfg->m_Window for top-level frames.
2020-12-18 14:04:03 +00:00
*
* @param aCfg is this frame's config object
*/
virtual WINDOW_SETTINGS* GetWindowSettings( APP_SETTINGS_BASE* aCfg );
/**
2020-12-18 14:04:03 +00:00
* Load frame state info from a configuration file
*/
virtual void LoadWindowState( const WINDOW_STATE& aState );
/**
2020-12-18 14:04:03 +00:00
* Get the configuration base name.
*
* This is usually the name of the frame set by CTOR, except for frames shown in
* multiple modes in which case the m_configName must be set to the base name so
* that a single configuration can be used.
*
* @return a base name prefix used in Load/Save settings to build the full name of keys
2020-12-18 14:04:03 +00:00
* used in configuration.
*/
wxString ConfigBaseName() override
{
wxString baseCfgName = m_configName.IsEmpty() ? GetName() : m_configName;
return baseCfgName;
}
/**
* Save changes to the project settings to the project (.pro) file.
*
* The method is virtual so you can override it to call the suitable save method.
2020-12-18 14:04:03 +00:00
* The base method does nothing.
*
* @param aAskForSave true to open a dialog before saving the settings.
*/
virtual void SaveProjectSettings() {};
2010-11-12 15:17:10 +00:00
/**
* Prompt the user for a hotkey file to read, and read it.
*
2020-12-18 14:04:03 +00:00
* @param aActionMap current hotkey map (over which the imported hotkeys will be applied).
* @param aDefaultShortname a default short name (extension not needed) like
* Eeschema, KiCad...
*/
void ImportHotkeyConfigFromFile( std::map<std::string, TOOL_ACTION*> aActionMap,
const wxString& aDefaultShortname );
/**
* Fetches the file name from the file history list.
*
* This removes the selected file, if this file does not exist. The menu is also updated,
2020-12-18 14:04:03 +00:00
* if #FILE_HISTORY::UseMenu was called at initialization time.
*
* @param cmdId The command ID associated with the \a aFileHistory object.
* @param type Please document me!
* @param aFileHistory The FILE_HISTORY in use. If null, the main application file
* history is used
* @return a wxString containing the selected filename
*/
wxString GetFileFromHistory( int cmdId, const wxString& type,
2020-05-16 21:47:01 +00:00
FILE_HISTORY* aFileHistory = nullptr );
/**
* Removes all files from the file history.
*
* @param aFileHistory The FILE_HISTORY in use. If null, the main application file
* history is used
*/
2020-05-16 21:47:01 +00:00
void ClearFileHistory( FILE_HISTORY* aFileHistory = nullptr );
/**
* Update the list of recently opened files.
*
* The menu is also updated, if FILE_HISTORY::UseMenu was called at init time.
*
* @param FullFileName The full file name including the path.
2020-12-18 14:04:03 +00:00
* @param aFileHistory The FILE_HISTORY in use. If NULL, the main application file
* history is used.
*/
2020-05-16 21:47:01 +00:00
void UpdateFileHistory( const wxString& FullFileName, FILE_HISTORY* aFileHistory = nullptr );
/**
* Get the frame's main file history.
*
* @return the main file history
*/
FILE_HISTORY& GetFileHistory()
{
return *m_fileHistory;
}
void SetMruPath( const wxString& aPath ) { m_mruPath = aPath; }
wxString GetMruPath() const { return m_mruPath; }
/**
* Get the full filename + path of the currently opened file in the frame.
2020-12-18 14:04:03 +00:00
*
* If no file is open, an empty string is returned.
*
* @return the filename and full path to the open file
*/
virtual wxString GetCurrentFileName() const { return wxEmptyString; }
2011-04-17 13:54:17 +00:00
/**
* Recreates the menu bar.
*
2011-04-17 13:54:17 +00:00
* Needed when the language is changed
*/
virtual void ReCreateMenuBar();
/**
* Adds the standard KiCad help menu to the menubar.
*/
void AddStandardHelpMenu( wxMenuBar* aMenuBar );
/**
* Checks if \a aFileName can be written.
2020-12-18 14:04:03 +00:00
*
* The function performs a number of tests on \a aFileName to verify that it can be saved.
* If \a aFileName defines a path with no file name, them the path is tested for user write
* permission. If \a aFileName defines a file name that does not exist in the path, the
* path is tested for user write permission. If \a aFileName defines a file that already
* exits, the file name is tested for user write permissions.
2020-12-18 14:04:03 +00:00
*>
* @note The file name path must be set or an assertion will be raised on debug builds and
* return false on release builds.
* @param aFileName The full path and/or file name of the file to test.
* @return False if \a aFileName cannot be written.
*/
bool IsWritable( const wxFileName& aFileName );
/**
* Check if an auto save file exists for \a aFileName and takes the appropriate action
* depending on the user input.
2020-12-18 14:04:03 +00:00
*
* If an auto save file exists for \a aFileName, the user is prompted if they wish to
* replace file \a aFileName with the auto saved file. If the user chooses to replace the
* file, the backup file of \a aFileName is removed, \a aFileName is renamed to the backup
* file name, and the auto save file is renamed to \a aFileName. If user chooses to keep
* the existing version of \a aFileName, the auto save file is removed.
2020-12-18 14:04:03 +00:00
*
* @param aFileName A wxFileName object containing the file name to check.
*/
void CheckForAutoSaveFile( const wxFileName& aFileName );
/**
* Update the status bar information.
*
* The status bar can draw itself. This is not a drawing function per se, but rather
* updates lines of text held by the components within the status bar which is owned
* by the wxFrame.
*/
virtual void UpdateStatusBar() { }
/**
* Redraw the menus and what not in current language.
*/
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
virtual void ShowChangedLanguage();
2017-03-03 13:18:07 +00:00
/**
* Notification event that some of the common (suite-wide) settings have changed.
* Update menus, toolbars, local variables, etc.
*/
void CommonSettingsChanged( bool aEnvVarsChanged, bool aTextVarsChanged ) override;
/**
* Notification event that the project has changed.
*/
virtual void ProjectChanged() {}
2020-11-16 11:16:44 +00:00
const wxString& GetAboutTitle() const { return m_aboutTitle; }
/**
* Get if the contents of the frame have been modified since the last save.
*
* @return true if the contents of the frame have not been saved
*/
virtual bool IsContentModified();
/**
* Get the undecorated window size that can be used for restoring the window size.
*
* This is needed for GTK, since the normal wxWidgets GetSize() call will return
* a window size that includes the window decorations added by the window manager.
*
* @return the undecorated window size
*/
wxSize GetWindowSize();
/**
2020-12-18 14:04:03 +00:00
* Remove the \a aItemCount of old commands from \a aList and delete commands, pickers
* and picked items if needed.
*
* Because picked items must be deleted only if they are not in use, this is a virtual
* pure function that must be created for #SCH_SCREEN and #PCB_SCREEN. Commands are
* deleted from the older to the last.
*
* @param aList = the #UNDO_REDO_CONTAINER of commands.
* @param aItemCount number of old commands to delete. -1 to remove all old commands
* this will empty the list of commands.
*/
2020-07-13 13:50:35 +00:00
enum UNDO_REDO_LIST { UNDO_LIST, REDO_LIST };
virtual void ClearUndoORRedoList( UNDO_REDO_LIST aList, int aItemCount = -1 )
{ }
/**
2020-12-18 14:04:03 +00:00
* Clear the undo and redo list using #ClearUndoORRedoList()
*
* Picked items are deleted by ClearUndoORRedoList() according to their status.
*/
virtual void ClearUndoRedoList();
/**
2020-12-18 14:04:03 +00:00
* Add a command to undo in the undo list.
*
* Delete the very old commands when the max count of undo commands is reached.
*/
virtual void PushCommandToUndoList( PICKED_ITEMS_LIST* aItem );
/**
2020-12-18 14:04:03 +00:00
* Add a command to redo in the redo list.
*
* Delete the very old commands when the max count of redo commands is reached.
*/
virtual void PushCommandToRedoList( PICKED_ITEMS_LIST* aItem );
2020-12-18 14:04:03 +00:00
/**
* Return the last command to undo and remove it from list, nothing is deleted.
*/
virtual PICKED_ITEMS_LIST* PopCommandFromUndoList();
2020-12-18 14:04:03 +00:00
/**
* Return the last command to undo and remove it from list, nothing is deleted.
*/
virtual PICKED_ITEMS_LIST* PopCommandFromRedoList();
virtual int GetUndoCommandCount() const { return m_undoList.m_CommandsList.size(); }
virtual int GetRedoCommandCount() const { return m_redoList.m_CommandsList.size(); }
2020-11-16 11:16:44 +00:00
int GetMaxUndoItems() const { return m_undoRedoCountMax; }
2020-08-24 02:10:05 +00:00
bool NonUserClose( bool aForce )
{
m_isNonUserClose = true;
return Close( aForce );
}
2020-12-18 14:04:03 +00:00
protected:
///< Default style flags used for wxAUI toolbars.
static constexpr int KICAD_AUI_TB_STYLE = wxAUI_TB_DEFAULT_STYLE | wxAUI_TB_PLAIN_BACKGROUND;
/**
* @return the suffix to be appended to the file extension on backup
*/
static wxString GetBackupSuffix()
{
return wxT( "-bak" );
}
/**
* @return the string to prepend to a file name for automatic save.
*/
static wxString GetAutoSaveFilePrefix()
{
return wxT( "_autosave-" );
}
/**
* Handle the auto save timer event.
*/
void onAutoSaveTimer( wxTimerEvent& aEvent );
/**
* Return the auto save status of the application.
*
* Override this function if your derived frame supports automatic file saving.
*/
virtual bool isAutoSaveRequired() const { return false; }
/**
* This should be overridden by the derived class to handle the auto save feature.
*
* @return true if the auto save was successful otherwise false.
*/
virtual bool doAutoSave();
virtual bool canCloseWindow( wxCloseEvent& aCloseEvent ) { return true; }
virtual void doCloseWindow() { }
/**
* Called when when the units setting has changed to allow for any derived classes
* to handle refreshing and controls that have units based measurements in them.
*
* The default version only updates the status bar. Don't forget to call the default
* in your derived class or the status bar will not get updated properly.
*/
virtual void unitsChangeRefresh() { }
/**
* Setup the UI conditions for the various actions and their controls in this frame.
*/
virtual void setupUIConditions();
DECLARE_EVENT_TABLE()
private:
/**
* (with its unexpected name so it does not collide with the real OnWindowClose()
* function provided in derived classes) is called just before a window
* closing, and is used to call a derivation specific SaveSettings().
*
* #SaveSettings() is called for all derived wxFrames in this base class overload.
* Calling it from a destructor is deprecated since the wxFrame's position is not
* available in the destructor on linux. In other words, you should not need to
* call #SaveSettings() anywhere, except in this one function found only in this class.
*/
void windowClosing( wxCloseEvent& event );
wxWindow* findQuasiModalDialog();
/**
* Return true if the frame is shown in our modal mode and false if the frame is
* shown as an usual frame.
*
* In modal mode, the caller that created the frame is responsible to Destroy()
* this frame after closing.
*/
virtual bool IsModal() const { return false; }
protected:
FRAME_T m_ident; // Id Type (pcb, schematic, library..)
wxPoint m_framePos;
wxSize m_frameSize;
bool m_maximizeByDefault;
// These contain the frame size and position for when it is not maximized
wxPoint m_normalFramePos;
wxSize m_normalFrameSize;
wxString m_aboutTitle; // Name of program displayed in About.
wxAuiManager m_auimgr;
wxString m_perspective; // wxAuiManager perspective.
WX_INFOBAR* m_infoBar; // Infobar for the frame
wxString m_configName; // Prefix used to identify some params (frame size...)
// and to name some config files (legacy hotkey files)
SETTINGS_MANAGER* m_settingsManager;
FILE_HISTORY* m_fileHistory; // The frame's recently opened file list
bool m_hasAutoSave;
bool m_autoSaveState;
int m_autoSaveInterval; // The auto save interval time in seconds.
wxTimer* m_autoSaveTimer;
int m_undoRedoCountMax; // undo/Redo command Max depth
UNDO_REDO_CONTAINER m_undoList; // Objects list for the undo command (old data)
UNDO_REDO_CONTAINER m_redoList; // Objects list for the redo command (old data)
wxString m_mruPath; // Most recently used path.
EDA_UNITS m_userUnits;
///< Map containing the UI update handlers registered with wx for each action.
std::map<int, UIUpdateHandler> m_uiUpdateMap;
///< Set by the close window event handler after frames are asked if they can close.
///< Allows other functions when called to know our state is cleanup.
bool m_isClosing;
///< Set by #NonUserClose() to indicate that the user did not request the current close.
bool m_isNonUserClose;
};
/**
* Specialization of the wxAuiPaneInfo class for KiCad panels.
*
* Documentation for wxAui is poor at this time. The following notes spring from errors made in
* previous KiCad implementations:
*
* wxAuiPaneInfo.ToolbarPane() and .Defaults() are used to clear and then prepare the objects so
* only use them once at the beginning of configuration..
*
* Panels are organized in layers, from 0 (close to the center) and increasing outward. Note
* that for ToolbarPanes, layer 0 considered a special default value, and ToolbarPanes on
* layer 0 are pushed to layer 10 automatically. Use Layer 1 for the inner layer as a work-
* around.
*
* Each panel has rows, starting at 0. Each row has positions starting at 0. Each item in a panel
* can have it's row and position set.
*
* Eventually panels will be movable. Each initialization function sets up the panel for this,
* then after a //==// break has additional calls to anchor toolbars in a way that matches
* present functionality.
*/
class EDA_PANE : public wxAuiPaneInfo
{
public:
EDA_PANE()
{
Gripper( false );
CloseButton( false );
PaneBorder( false );
}
/**
* Turn *this to a horizontal toolbar for KiCad.
*/
EDA_PANE& HToolbar()
{
SetFlag( optionToolbar, true );
CaptionVisible( false );
TopDockable().BottomDockable();
DockFixed( true );
Movable( false );
Resizable( true ); // expand to fit available space
return *this;
}
/**
* Turn *this into a vertical toolbar for KiCad.
*/
EDA_PANE& VToolbar()
{
SetFlag( optionToolbar, true );
CaptionVisible( false );
LeftDockable().RightDockable();
DockFixed( true );
Movable( false );
Resizable( true ); // expand to fit available space
return *this;
}
/**
* Turn *this into a captioned palette suitable for a symbol tree, layers manager, etc.
*/
EDA_PANE& Palette()
{
CaptionVisible( true );
PaneBorder( true );
return *this;
}
/**
* Turn *this into an undecorated pane suitable for a drawing canvas.
*/
EDA_PANE& Canvas()
{
CaptionVisible( false );
Layer( 0 );
PaneBorder( true );
Resizable( true ); // expand to fit available space
return *this;
}
/**
* Turn *this into a messages pane for KiCad.
*/
EDA_PANE& Messages()
{
CaptionVisible( false );
BottomDockable( true );
DockFixed( true );
Movable( false );
Resizable( true ); // expand to fit available space
return *this;
}
/**
* Turn *this into a infobar for KiCad.
*/
EDA_PANE& InfoBar()
{
CaptionVisible( false );
Movable( false );
Resizable( true );
PaneBorder( false );
DockFixed( true );
return *this;
}
};
2019-12-19 14:22:42 +00:00
#endif // EDA_BASE_FRAME_H_