kicad/include/wxstruct.h

666 lines
23 KiB
C
Raw Normal View History

2009-11-23 20:18:47 +00:00
/****************/
/* wxstruct.h */
/****************/
#ifndef WXSTRUCT_H
#define WXSTRUCT_H
#include <vector>
#include <wx/socket.h>
#include "wx/log.h"
#include "wx/config.h"
#include <wx/wxhtml.h>
#include <wx/laywin.h>
2009-11-02 22:24:55 +00:00
#include <wx/aui/aui.h>
2010-02-01 21:23:27 +00:00
#include "colors.h"
#include "common.h"
2007-10-10 18:01:14 +00:00
//C++ guarantees that operator delete checks its argument for null-ness
#ifndef SAFE_DELETE
#define SAFE_DELETE( p ) delete (p); (p) = NULL;
#endif
#ifndef EESCHEMA_INTERNAL_UNIT
#define EESCHEMA_INTERNAL_UNIT 1000
#endif
// Option for dialog boxes
#define DIALOG_STYLE wxDEFAULT_DIALOG_STYLE | wxFRAME_FLOAT_ON_PARENT | \
MAYBE_RESIZE_BORDER
#define KICAD_DEFAULT_DRAWFRAME_STYLE wxDEFAULT_FRAME_STYLE | wxWANTS_CHARS
class EDA_ITEM;
class EDA_Rect;
class WinEDA_DrawPanel;
class WinEDA_MsgPanel;
class BASE_SCREEN;
class WinEDA_Toolbar;
class WinEDAChoiceBox;
class PARAM_CFG_BASE;
class Ki_PageDescr;
class Ki_HotkeyInfo;
class PLOTTER;
2007-08-04 04:42:49 +00:00
enum id_librarytype {
LIBRARY_TYPE_EESCHEMA,
LIBRARY_TYPE_PCBNEW,
LIBRARY_TYPE_DOC,
LIBRARY_TYPE_SYMBOL
};
enum id_drawframe {
2007-08-04 04:42:49 +00:00
NOT_INIT_FRAME = 0,
SCHEMATIC_FRAME,
LIBEDITOR_FRAME,
VIEWER_FRAME,
PCB_FRAME,
MODULE_EDITOR_FRAME,
CVPCB_FRAME,
CVPCB_DISPLAY_FRAME,
GERBER_FRAME,
TEXT_EDITOR_FRAME,
DISPLAY3D_FRAME,
KICAD_MAIN_FRAME
};
enum id_toolbar {
TOOLBAR_MAIN = 1, // Main horizontal Toolbar
TOOLBAR_TOOL, // Right vertical Toolbar (list of tools)
TOOLBAR_OPTION, // Left vertical Toolbar (option toolbar
TOOLBAR_AUX // Secondary horizontal Toolbar
};
/***********************************************/
/* Classes for basic main frames used in kicad */
/***********************************************/
2007-08-04 04:42:49 +00:00
/******************************************************************/
/* Basic frame for kicad, eeschema, pcbnew and gerbview. */
/* not directly used: the real frames are derived from this class */
/******************************************************************/
2007-08-04 04:42:49 +00:00
class WinEDA_BasicFrame : public wxFrame
{
public:
2007-08-04 04:42:49 +00:00
int m_Ident; // Id Type (pcb, schematic, library..)
wxPoint m_FramePos;
wxSize m_FrameSize;
int m_MsgFrameHeight;
WinEDA_Toolbar* m_HToolBar; // Standard horizontal Toolbar
bool m_FrameIsActive;
wxString m_FrameName; // name used for writing and reading setup
2007-08-04 04:42:49 +00:00
// It is "SchematicFrame", "PcbFrame" ....
wxString m_AboutTitle; // Name of program displayed in About.
2009-11-02 22:24:55 +00:00
wxAuiManager m_auimgr;
public:
WinEDA_BasicFrame( wxWindow* father, int idtype,
2007-08-04 04:42:49 +00:00
const wxString& title,
const wxPoint& pos, const wxSize& size,
long style = KICAD_DEFAULT_DRAWFRAME_STYLE );
2007-09-01 12:00:30 +00:00
~WinEDA_BasicFrame();
void GetKicadHelp( wxCommandEvent& event );
void GetKicadAbout( wxCommandEvent& event );
/**
* Copy the version information to the clipboard for bug reporting purposes.
*/
void CopyVersionInfoToClipboard( wxCommandEvent& event );
void PrintMsg( const wxString& text );
/**
* Append the copy version information to clipboard help menu entry to \a aMenu.
*
* @param aMenu - The menu to append.
*/
void AddHelpVersionInfoMenuEntry( wxMenu* aMenu );
virtual void LoadSettings();
virtual void SaveSettings();
// Read/Save and Import/export hotkeys config
2010-11-12 15:17:10 +00:00
/**
* Function ReadHotkeyConfig
* Read configuration data and fill the current hotkey list with hotkeys
* @param aDescList = current hotkey list descr. to initialise.
*/
int ReadHotkeyConfig( struct Ki_HotkeyInfoSectionDescriptor* aDescList );
2010-11-12 15:17:10 +00:00
/**
* Function WriteHotkeyConfig
* Store the current hotkey list
* It is stored using the standard wxConfig mechanism or a file.
*
* @param aDescList = pointer to the current hotkey list.
* @param aFullFileName = a wxString pointer to a fuill file name.
* if NULL, use the standard wxConfig mechanism (default)
* the output format is: shortcut "key" "function"
* lines starting with # are comments
*/
int WriteHotkeyConfig( struct Ki_HotkeyInfoSectionDescriptor* aDescList,
wxString * aFullFileName = NULL);
2010-11-12 15:17:10 +00:00
/**
* Function ReadHotkeyConfigFile
* Read an old configuration file (&ltfile&gt.key) and fill the current hotkey list
* with hotkeys
* @param aFilename = file name to read.
* @param aDescList = current hotkey list descr. to initialise.
*/
int ReadHotkeyConfigFile( const wxString& aFilename,
struct Ki_HotkeyInfoSectionDescriptor* aDescList );
2010-11-12 15:17:10 +00:00
/**
* Function ImportHotkeyConfigFromFile
* Prompt the user for an old hotkey file to read, and read it.
* @param aDescList = current hotkey list descr. to initialise.
*/
void ImportHotkeyConfigFromFile( struct Ki_HotkeyInfoSectionDescriptor* aDescList );
2010-11-12 15:17:10 +00:00
/**
* Function ExportHotkeyConfigToFile
* Prompt the user for an old hotkey file to read, and read it.
* @param aDescList = current hotkey list descr. to initialise.
*/
void ExportHotkeyConfigToFile( struct Ki_HotkeyInfoSectionDescriptor* aDescList );
2010-11-12 15:17:10 +00:00
/**
* Function SetLanguage
* called on a language menu selection
* when using a derived function, do not forget to call this one
*/
virtual void SetLanguage( wxCommandEvent& event );
wxString GetFileFromHistory( int cmdId, const wxString& type );
void SetLastProject( const wxString& FullFileName );
void DisplayActivity( int PerCent, const wxString& Text );
virtual void ReCreateMenuBar();
};
/*******************************************************/
/* Basic draw frame for eeschema, pcbnew and gerbview. */
/*******************************************************/
2007-08-04 04:42:49 +00:00
class WinEDA_DrawFrame : public WinEDA_BasicFrame
{
public:
WinEDA_DrawPanel* DrawPanel; // Draw area
2009-11-23 20:18:47 +00:00
WinEDA_MsgPanel* MsgPanel; // Panel used to display some
// info (bottom of the screen)
2007-08-04 04:42:49 +00:00
WinEDA_Toolbar* m_VToolBar; // Vertical (right side) Toolbar
2009-11-23 20:18:47 +00:00
WinEDA_Toolbar* m_AuxVToolBar; // Auxiliary Vertical (right side)
// Toolbar
2007-08-04 04:42:49 +00:00
WinEDA_Toolbar* m_OptionsToolBar; // Options Toolbar (left side)
WinEDA_Toolbar* m_AuxiliaryToolBar; // Auxiliary Toolbar used in pcbnew
2009-11-23 20:18:47 +00:00
WinEDAChoiceBox* m_SelGridBox; // Choice box to choose the grid
// size
WinEDAChoiceBox* m_SelZoomBox; // Choice box to choose the zoom
// value
int m_CursorShape; // shape for cursor (0 = default
// cursor)
int m_ID_current_state; // Id of active button on the
// vertical toolbar
int m_ID_last_state; // Id of previous active button
// on the vertical toolbar
int m_HTOOL_current_state; // Id of active button on
// horizontal toolbar
2007-08-04 04:42:49 +00:00
int m_InternalUnits; // Internal units count in 1 inch
2009-11-23 20:18:47 +00:00
// = 1000 for eeschema, = 10000
// for PCBnew and Gerbview
bool m_Draw_Axis; // TRUE to show X and Y axis
bool m_Draw_Grid_Axis; /* TRUE to show grid axis. */
bool m_Draw_Sheet_Ref; // TRUE to show frame references
2007-08-04 04:42:49 +00:00
bool m_Print_Sheet_Ref; // TRUE to print frame references
2009-11-23 20:18:47 +00:00
bool m_Draw_Auxiliary_Axis; /* TRUE to show auxiliary axis.
* Used in pcbnew: the auxiliary
* axis is the origin of
* coordinates for drill, gerber
* and component position files
*/
wxPoint m_Auxiliary_Axis_Position; /* position of the auxiliary axis */
2007-08-04 04:42:49 +00:00
protected:
Ki_HotkeyInfoSectionDescriptor * m_HotkeysZoomAndGridList;
int m_LastGridSizeId;
2010-02-01 21:23:27 +00:00
bool m_DrawGrid; // hide/Show grid
int m_GridColor; // Grid color
private:
BASE_SCREEN* m_CurrentScreen; ///< current used SCREEN
protected:
2009-11-23 20:18:47 +00:00
void SetBaseScreen( BASE_SCREEN* aScreen )
{
m_CurrentScreen = aScreen;
}
public:
WinEDA_DrawFrame( wxWindow* father, int idtype,
2007-08-04 04:42:49 +00:00
const wxString& title,
const wxPoint& pos, const wxSize& size,
2008-03-20 01:50:21 +00:00
long style = KICAD_DEFAULT_DRAWFRAME_STYLE );
2007-08-04 04:42:49 +00:00
2007-09-01 12:00:30 +00:00
~WinEDA_DrawFrame();
virtual wxString GetScreenDesc();
2007-08-04 04:42:49 +00:00
/**
* Function GetBaseScreen
* is virtual and returns a pointer to a BASE_SCREEN or one of its
* derivatives. It may be overloaded by derived classes.
*/
virtual BASE_SCREEN* GetBaseScreen() const { return m_CurrentScreen; }
void OnMenuOpen( wxMenuEvent& event );
void OnMouseEvent( wxMouseEvent& event );
virtual void OnHotKey( wxDC* DC, int hotkey, EDA_ITEM* DrawStruct );
2010-11-12 15:17:10 +00:00
/**
* Function AddMenuZoomAndGrid (virtual)
* Add standard zoom commands and submenu zoom and grid selection to a popup menu
* uses zoom hotkeys info base to add hotkeys info to menu commands
* @param aMasterMenu = the menu to populate.
*/
virtual void AddMenuZoomAndGrid( wxMenu* aMasterMenu );
void Affiche_Message( const wxString& message );
void EraseMsgBox();
void Process_PageSettings( wxCommandEvent& event );
virtual void SetToolbars();
2010-11-12 15:17:10 +00:00
/**
* Function SetLanguage
* called on a language menu selection
* when using a derived function, do not forget to call this one
*/
virtual void SetLanguage( wxCommandEvent& event );
virtual void ReCreateHToolbar() = 0;
virtual void ReCreateVToolbar() = 0;
virtual void ReCreateMenuBar();
virtual void ReCreateAuxiliaryToolbar();
2010-11-12 15:17:10 +00:00
/**
* Function SetToolID
2010-07-27 16:49:38 +00:00
* Enables the icon of the selected tool in the vertical toolbar.
* (Or tool ID_NO_SELECT_BUTT default if no new selection)
* @param aId = new m_ID_current_state value (if aId >= 0)
* @param aCursor = the new cursor shape
* @param aToolMsg = tool message in status bar
* if (aId >= 0)
* Updates all variables related:
* m_ID_current_state, cursor shape and message in status bar
* If (aId < 0)
* Only updates the cursor shape and message in status bar
* (does not the current m_ID_current_state value
*/
virtual void SetToolID( int aId, int aCursor, const wxString& aToolMsg );
/* These 4 functions provide a basic way to show/hide grid
2010-02-01 21:23:27 +00:00
* and /get/set grid color.
* These parameters are saved in kicad config for each main frame
2010-02-01 21:23:27 +00:00
*/
2010-11-12 15:17:10 +00:00
/**
* Function IsGridVisible() , virtual
2010-02-01 21:23:27 +00:00
* @return true if the grid must be shown
*/
virtual bool IsGridVisible()
{
return m_DrawGrid;
}
2010-11-12 15:17:10 +00:00
/**
* Function SetGridVisibility() , virtual
2010-02-01 21:23:27 +00:00
* It may be overloaded by derived classes
* @param aVisible = true if the grid must be shown
*/
virtual void SetGridVisibility( bool aVisible )
2010-02-01 21:23:27 +00:00
{
m_DrawGrid = aVisible;
}
2010-11-12 15:17:10 +00:00
/**
* Function GetGridColor() , virtual
2010-02-01 21:23:27 +00:00
* @return the color of the grid
*/
virtual int GetGridColor()
{
return m_GridColor;
}
2010-11-12 15:17:10 +00:00
/**
* Function SetGridColor() , virtual
2010-02-01 21:23:27 +00:00
* @param aColor = the new color of the grid
*/
virtual void SetGridColor( int aColor )
2010-02-01 21:23:27 +00:00
{
m_GridColor = aColor;
}
/**
* Command event handler for selecting grid sizes.
*
* All commands that set the grid size should eventually end up here.
* This is where the application setting is saved. If you override
* this method, make sure you call down to the base class.
*
* @param event - Command event passed by selecting grid size from the
* grid size combobox on the toolbar.
*/
virtual void OnSelectGrid( wxCommandEvent& event );
virtual void OnSelectZoom( wxCommandEvent& event );
virtual void GeneralControle( wxDC* DC, wxPoint Mouse ) { /* dummy */ }
virtual void OnSize( wxSizeEvent& event );
void OnEraseBackground( wxEraseEvent& SizeEvent );
2007-08-04 04:42:49 +00:00
void SetToolbarBgColor( int color_num );
virtual void OnZoom( wxCommandEvent& event );
void OnGrid( int grid_type );
void Recadre_Trace( bool ToMouse );
2010-11-12 15:17:10 +00:00
/** Adjust the coordinate to the nearest grid value
* @param aCoord = coordinate to adjust
2010-11-12 15:17:10 +00:00
* @param aGridSize = pointer to a grid value. if NULL uses the current grid size
*/
2010-11-12 15:17:10 +00:00
void PutOnGrid( wxPoint* aCoord , wxRealPoint* aGridSize = NULL );
void Zoom_Automatique( bool move_mouse_cursor );
2007-08-04 04:42:49 +00:00
/* Set the zoom level to show the area Rect */
void Window_Zoom( EDA_Rect& Rect );
2007-08-04 04:42:49 +00:00
/* Return the zoom level which displays the full page on screen */
virtual int BestZoom() = 0;
2007-08-04 04:42:49 +00:00
/* Return the current zoom level */
int GetZoom( void );
void TraceWorkSheet( wxDC* DC, BASE_SCREEN* screen, int line_width );
void PlotWorkSheet( PLOTTER *plotter, BASE_SCREEN* screen );
2010-11-12 15:17:10 +00:00
/**
* Function GetXYSheetReferences
* Return the X,Y sheet references where the point position is located
* @param aScreen = screen to use
* @param aPosition = position to identify by YX ref
2009-11-23 20:18:47 +00:00
* @return a wxString containing the message locator like A3 or B6
* (or ?? if out of page limits)
*/
wxString GetXYSheetReferences( BASE_SCREEN* aScreen, const wxPoint& aPosition );
void DisplayToolMsg( const wxString& msg );
void Process_Zoom( wxCommandEvent& event );
void Process_Grid( wxCommandEvent& event );
virtual void RedrawActiveWindow( wxDC* DC, bool EraseBg ) = 0;
virtual void OnLeftClick( wxDC* DC, const wxPoint& MousePos ) = 0;
virtual void OnLeftDClick( wxDC* DC, const wxPoint& MousePos );
virtual bool OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu ) = 0;
virtual void ToolOnRightClick( wxCommandEvent& event );
void AdjustScrollBars();
/**
* Function OnActivate (virtual)
* is called when activating the frame.
* In derived classes with a overriding OnActivate function,
* do not forget to call this WinEDA_DrawFrame::OnActivate( event ) basic function.
*/
virtual void OnActivate( wxActivateEvent& event );
/**
* Function UpdateStatusBar
* updates the status bar information.
*
* The base method updates the absolute and relative coordinates and the
* zoom information. If you override this virtual method, make sure to call
* this subclassed method. 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.
* <p>
2009-11-23 20:18:47 +00:00
* On a MAC, be careful about calling this function when there is an
* existing wxDC in existence on a sibling window.
*/
virtual void UpdateStatusBar();
void DisplayUnitsMsg();
2007-08-04 04:42:49 +00:00
/* Handlers for block commands */
virtual void InitBlockPasteInfos();
virtual bool HandleBlockBegin( wxDC* DC, int cmd_type,const wxPoint& startpos );
/**
* Function ReturnBlockCommand
* Returns the block command internat code (BLOCK_MOVE, BLOCK_COPY...)
* corresponding to the keys pressed (ALT, SHIFT, SHIFT ALT ..) when
* block command is started by dragging the mouse.
* @param aKey = the key modifiers (Alt, Shift ...)
* @return the block command id (BLOCK_MOVE, BLOCK_COPY...)
*/
virtual int ReturnBlockCommand( int aKey );
/**
* Function HandleBlockPlace( )
* Called after HandleBlockEnd, when a block command needs to be
* executed after the block is moved to its new place
* (bloc move, drag, copy .. )
* Parameters must be initialized in GetScreen()->m_BlockLocate
*/
virtual void HandleBlockPlace( wxDC* DC );
/**
* Function HandleBlockEnd( )
* Handle the "end" of a block command,
* i.e. is called at the end of the definition of the area of a block.
* depending on the current block command, this command is executed
* or parameters are initialized to prepare a call to HandleBlockPlace
* in GetScreen()->m_BlockLocate
* @return false if no item selected, or command finished,
* true if some items found and HandleBlockPlace must be called later
*/
virtual bool HandleBlockEnd( wxDC* DC );
2007-08-04 04:42:49 +00:00
void CopyToClipboard( wxCommandEvent& event );
2007-08-04 04:42:49 +00:00
/* interprocess communication */
void OnSockRequest( wxSocketEvent& evt );
void OnSockRequestServer( wxSocketEvent& evt );
virtual void LoadSettings();
virtual void SaveSettings();
/**
* Append a message to the message panel.
*
* This helper method checks to make sure the message panel exists in
* the frame and appends a message to it using the message panel
* AppendMessage() method.
*
* @param textUpper - The message upper text.
* @param textLower - The message lower text.
* @param color - A color ID from the Kicad color list (see colors.h).
* @param pad - Number of spaces to pad between messages (default = 4).
*/
void AppendMsgPanel( const wxString& textUpper, const wxString& textLower,
int color, int pad = 6 );
/**
* Clear all messages from the message panel.
*/
void ClearMsgPanel( void );
/** Virtual function PrintPage
* used to print a page
* Print the page pointed by ActiveScreen, set by the calling print function
* @param aDC = wxDC given by the calling print function
* @param aPrint_Sheet_Ref = true to print page references
* @param aPrintMask = not used here
* @param aPrintMirrorMode = not used here (Set when printing in mirror mode)
* @param aData = a pointer on an auxiliary data (not always used, NULL if not used)
*/
virtual void PrintPage( wxDC* aDC, bool aPrint_Sheet_Ref,
int aPrintMask, bool aPrintMirrorMode,
void * aData = NULL);
2010-10-04 12:58:07 +00:00
DECLARE_EVENT_TABLE()
2009-01-07 15:59:49 +00:00
};
/*********************************************************
* class WinEDA_MsgPanel : this is a panel to display various infos
* and messages on items in eeschema an pcbnew
*********************************************************/
2007-10-10 18:01:14 +00:00
/**
* Struct MsgItem
2007-10-11 00:11:59 +00:00
* is used privately by WinEDA_MsgPanel as the item type of its vector.
2007-10-10 18:01:14 +00:00
* These items are the pairs of text strings shown in the MsgPanel.
*/
struct MsgItem
{
int m_X;
int m_UpperY;
int m_LowerY;
wxString m_UpperText;
wxString m_LowerText;
int m_Color;
2007-10-10 18:01:14 +00:00
/**
* Function operator=
* overload the assignment operator so that the wxStrings get copied
* properly when copying a MsgItem.
* No, actually I'm not sure this needed, C++ compiler may auto-generate it.
*/
MsgItem& operator=( const MsgItem& rv )
{
m_X = rv.m_X;
2007-10-10 18:01:14 +00:00
m_UpperY = rv.m_UpperY;
m_LowerY = rv.m_LowerY;
m_UpperText = rv.m_UpperText; // overloaded operator=()
m_LowerText = rv.m_LowerText; // overloaded operator=()
m_Color = rv.m_Color;
return * this;
2007-10-10 18:01:14 +00:00
}
};
2007-08-04 04:42:49 +00:00
class WinEDA_MsgPanel : public wxPanel
{
2007-10-10 18:01:14 +00:00
protected:
std::vector<MsgItem> m_Items;
int m_last_x; ///< the last used x coordinate
wxSize m_fontSize;
2008-03-31 13:46:00 +00:00
void showItem( wxDC& dc, const MsgItem& aItem );
2007-10-10 18:01:14 +00:00
void erase( wxDC* DC );
2008-03-20 01:50:21 +00:00
/**
* Function getFontSize
* computes the height and width of a 'W' in the system font.
*/
static wxSize computeFontSize();
/**
* Calculate the width and height of a text string using the system UI font.
*/
wxSize computeTextSize( const wxString& text );
public:
2007-08-04 04:42:49 +00:00
WinEDA_DrawFrame* m_Parent;
2009-11-23 20:18:47 +00:00
int m_BgColor;
public:
2009-11-23 20:18:47 +00:00
WinEDA_MsgPanel( WinEDA_DrawFrame* parent, int id, const wxPoint& pos,
const wxSize& size );
2007-09-01 12:00:30 +00:00
~WinEDA_MsgPanel();
2007-08-04 04:42:49 +00:00
/**
* Function GetRequiredHeight
* returns the required height (in pixels) of a WinEDA_MsgPanel. This takes
* into consideration the system gui font, wxSYS_DEFAULT_GUI_FONT.
*/
static int GetRequiredHeight();
void OnPaint( wxPaintEvent& event );
void EraseMsgBox();
void Affiche_1_Parametre( int pos_X, const wxString& texte_H,
const wxString& texte_L, int color );
/**
* Append a message to the message panel.
*
* This method automatically adjusts for the width of the text string.
* Making consecutive calls to AppendMessage will append each message
* to the right of the last message. This message is not compatible
* with Affiche_1_Parametre.
*
* @param textUpper - The message upper text.
* @param textLower - The message lower text.
* @param color - A color ID from the Kicad color list (see colors.h).
* @param pad - Number of spaces to pad between messages (default = 4).
*/
void AppendMessage( const wxString& textUpper, const wxString& textLower,
int color, int pad = 6 );
2007-08-04 04:42:49 +00:00
DECLARE_EVENT_TABLE()
};
2007-08-04 04:42:49 +00:00
/*************************/
/* class WinEDA_Toolbar */
/*************************/
2009-11-02 22:24:55 +00:00
class WinEDA_Toolbar : public wxAuiToolBar
{
public:
2007-08-04 04:42:49 +00:00
wxWindow* m_Parent;
id_toolbar m_Ident;
bool m_Horizontal; // some auxiliary TB are horizontal, others vertical
public:
WinEDA_Toolbar( id_toolbar type, wxWindow* parent, wxWindowID id, bool horizontal );
2009-11-02 22:24:55 +00:00
bool GetToolState( int toolId ) { return GetToolToggled(toolId); };
2009-11-02 22:24:55 +00:00
2009-11-23 20:18:47 +00:00
void AddRadioTool( int toolid,
const wxString& label,
const wxBitmap& bitmap,
const wxBitmap& bmpDisabled = wxNullBitmap,
const wxString& shortHelp = wxEmptyString,
const wxString& longHelp = wxEmptyString,
wxObject* data = NULL )
{
2009-11-23 20:18:47 +00:00
AddTool( toolid, label, bitmap, bmpDisabled, wxITEM_CHECK,
shortHelp, longHelp, data );
2009-11-02 22:24:55 +00:00
};
void SetToolNormalBitmap( int id, const wxBitmap& bitmap ) {};
void SetRows( int nRows ) {};
2010-02-01 21:23:27 +00:00
2010-11-12 15:17:10 +00:00
/**
* Function GetDimension
* @return the dimension of this toolbar (Height if horizontal, Width if vertical.
*/
int GetDimension( );
};
#endif /* WXSTRUCT_H */