While the original frontend of Mutabor was designed using Borland OWL the current one uses the platform independent environment provided by wxWidgets. Mehr ...

Zusammengehörigkeiten von wxWidgets Mutabor GUI:

Klassen
class	MutApp
	Mutabor application class. Mehr ...
class	AppAbout
	About Dialog. Mehr ...
class	MutToolBarBitmaps
	Toolbar bitmaps. Mehr ...
class	MutConfigDialog
class	MutFrame
class	MutTag
class	MutLogicWnd
class	WinAttr
class	MutTextBox
class	MutPanel
Namensbereiche
namespace	mutaborGUI
	Main mutabor frame class.
Makrodefinitionen
#define	OPENMENU menu = new wxMenu;
#define	CLOSEMENU(name) menuBar->Append(menu, name);
#define	MENUITEM(name, id, help) menu->Append(id, name, help)
#define	MENUCHECKITEM(name, id, help) menu->AppendCheckItem(id, name, help)
#define	MENUITEM_ADD(name, id, help, add) menu->Append(id, name, help, add)
#define	MENUITEM_SEPARATOR menu->AppendSeparator()
#define	PACKAGE_NAME "Mutabor"
#define	APPNAME _(PACKAGE_NAME)
#define	SG_NOTHING 1
#define	SG_LOGIC 0
#define	SG_RECORD 2
#define	SG_PLAY 3
#define	SG_PAUSE 4
#define	Compiled (!CompiledFile.IsEmpty())
#define	MUTTAGX 90
#define	MUTTAGY 70
#define	max(a, b) ((a) < (b) ? (b) : (a))
Aufzählungen
enum	WinKind { WK_KEY = 0, WK_TS, WK_ACT, WK_LOGIC, WK_ROUTE, WK_EDIT, WK_NULL }
Funktionen
	IMPLEMENT_APP (MutApp) bool MutApp
	BEGIN_EVENT_TABLE (MutConfigDialog, ConfigDlg) EVT_BUTTON(
	BEGIN_EVENT_TABLE (MutApp, wxApp) EVT_MENU(CM_SETUP
MutApp::CmSetup	EVT_MENU (wxID_OPEN, MutApp::PassEventToDocManagerCMD) EVT_MENU(wxID_CLOSE
MutApp::CmSetup MutApp::PassEventToDocManagerCMD	EVT_MENU (wxID_CLOSE_ALL, MutApp::PassEventToDocManagerCMD) EVT_MENU(wxID_REVERT
MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD	EVT_MENU (wxID_NEW, MutApp::PassEventToDocManagerCMD) EVT_MENU(wxID_SAVE
MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD	EVT_MENU (wxID_SAVEAS, MutApp::PassEventToDocManagerCMD) EVT_MENU(wxID_UNDO
MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD	EVT_MENU (wxID_REDO, MutApp::PassEventToDocManagerCMD) EVT_UPDATE_UI(wxID_OPEN
MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD	EVT_UPDATE_UI (wxID_CLOSE, MutApp::PassEventToDocManagerUPD) EVT_UPDATE_UI(wxID_CLOSE_ALL
MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD	EVT_UPDATE_UI (wxID_REVERT, MutApp::PassEventToDocManagerUPD) EVT_UPDATE_UI(wxID_NEW
MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD	EVT_UPDATE_UI (wxID_SAVE, MutApp::PassEventToDocManagerUPD) EVT_UPDATE_UI(wxID_SAVEAS
MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD	EVT_UPDATE_UI (wxID_UNDO, MutApp::PassEventToDocManagerUPD) EVT_UPDATE_UI(wxID_REDO
MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD	EVT_MENU (CM_EXECUTE, MutApp::CmFileOpen) EVT_MENU_RANGE(wxID_FILE1
MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::OnMRUFile	EVT_MENU (CM_ROUTES, MutApp::CmRoutes) EVT_MENU(CM_ROUTELOAD
MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::OnMRUFile MutApp::CmRouteLoad	EVT_MENU (CM_ROUTESAVE, MutApp::CmRouteSave) EVT_MENU(CM_ROUTESAVEAS
MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::OnMRUFile MutApp::CmRouteLoad MutApp::CmRouteSaveAs	EVT_MENU (CM_HELP, MutApp::CmHelp) EVT_MENU(CM_HELPHANDBOOK
MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::OnMRUFile MutApp::CmRouteLoad MutApp::CmRouteSaveAs MutApp::CmHelp	EVT_MENU (CM_HELPREFERENCE, MutApp::CmHelp) EVT_MENU(CM_HELPINDEX
MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::OnMRUFile MutApp::CmRouteLoad MutApp::CmRouteSaveAs MutApp::CmHelp MutApp::CmHelp	EVT_MENU (CM_HELPSEARCH, MutApp::CmHelp) EVT_MENU(CM_HELPONHELP
MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::OnMRUFile MutApp::CmRouteLoad MutApp::CmRouteSaveAs MutApp::CmHelp MutApp::CmHelp MutApp::CmHelp	EVT_MENU (CM_ABOUT, MutApp::CmAbout) EVT_MENU(CM_EXIT
MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::OnMRUFile MutApp::CmRouteLoad MutApp::CmRouteSaveAs MutApp::CmHelp MutApp::CmHelp MutApp::CmHelp MutApp::CmQuit	END_EVENT_TABLE () MutFrame *MutApp
	WX_DECLARE_HASH_MAP (wxFrame , wxFrame , wxPointerHash, wxPointerEqual, FrameHash)
	Declare a frame array as an hash table.
static void	initMutBitmap (wxBitmap &bitmap, const wxString &filename, const wxBitmapType type)
	WX_DEFINE_OBJARRAY (ArrayOfWinAttr)
	BEGIN_EVENT_TABLE (MutChild, MutTextBox) EVT_CLOSE(MutChild
WinAttr *	GetWinAttr (WinKind kind, int box)
WinAttr *	Get (WinKind kind, int box)
bool	IsOpen (WinKind kind, int box)
bool	IsWanted (WinKind kind, int box)
void	DontWant (WinKind kind, int box)
int	NumberOfOpen (WinKind kind)
	BEGIN_EVENT_TABLE (MutEditFile, wxStyledTextCtrl) EVT_MENU(CM_COMPILE
MutEditFile::CmCompile	EVT_MENU (CM_COMPACT, MutEditFile::CmCompAct) EVT_MENU(CM_ACTIVATE
MutEditFile::CmCompile MutEditFile::CmCompAct	EVT_MENU (CM_GETLINE, MutEditFile::CmGetLine) EVT_MENU(CM_HELPCONTEXT
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext	EVT_SIZE (MutEditFile::OnSize) EVT_MENU(wxID_CLEAR
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear	EVT_MENU (wxID_CUT, MutEditFile::OnEditCut) EVT_MENU(wxID_COPY
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy	EVT_MENU (wxID_PASTE, MutEditFile::OnEditPaste) EVT_MENU(CM_INDENTINC
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc	EVT_MENU (CM_INDENTRED, MutEditFile::OnEditIndentRed) EVT_MENU(wxID_SELECTALL
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll	EVT_MENU (CM_SELECTLINE, MutEditFile::OnEditSelectLine) EVT_MENU(wxID_REDO
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo	EVT_MENU (wxID_UNDO, MutEditFile::OnEditUndo) EVT_MENU(wxID_FIND
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind	EVT_MENU (CM_FINDNEXT, MutEditFile::OnFindNext) EVT_MENU(CM_REPLACE
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace	EVT_MENU (CM_REPLACENEXT, MutEditFile::OnReplaceNext) EVT_MENU(CM_BRACEMATCH
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch	EVT_MENU (CM_GOTO, MutEditFile::OnGoto) EVT_MENU_RANGE(CM_HILIGHTFIRST
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang	EVT_MENU (CM_DISPLAYEOL, MutEditFile::OnDisplayEOL) EVT_MENU(CM_INDENTGUIDE
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang MutEditFile::OnIndentGuide	EVT_MENU (CM_LINENUMBER, MutEditFile::OnLineNumber) EVT_MENU(CM_LONGLINEON
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang MutEditFile::OnIndentGuide MutEditFile::OnLongLineOn	EVT_MENU (CM_WHITESPACE, MutEditFile::OnWhiteSpace) EVT_MENU(CM_FOLDTOGGLE
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang MutEditFile::OnIndentGuide MutEditFile::OnLongLineOn MutEditFile::OnFoldToggle	EVT_MENU (CM_OVERTYPE, MutEditFile::OnSetOverType) EVT_MENU(CM_READONLY
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang MutEditFile::OnIndentGuide MutEditFile::OnLongLineOn MutEditFile::OnFoldToggle MutEditFile::OnSetReadOnly	EVT_MENU (CM_WRAPMODEON, MutEditFile::OnWrapmodeOn) EVT_MENU(CM_CHARSETANSI
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang MutEditFile::OnIndentGuide MutEditFile::OnLongLineOn MutEditFile::OnFoldToggle MutEditFile::OnSetReadOnly MutEditFile::OnUseCharset	EVT_MENU (CM_CHARSETMAC, MutEditFile::OnUseCharset) EVT_MENU(CM_CHANGELOWER
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang MutEditFile::OnIndentGuide MutEditFile::OnLongLineOn MutEditFile::OnFoldToggle MutEditFile::OnSetReadOnly MutEditFile::OnUseCharset MutEditFile::OnChangeCase	EVT_MENU (CM_CHANGEUPPER, MutEditFile::OnChangeCase) EVT_MENU(CM_CONVERTCR
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang MutEditFile::OnIndentGuide MutEditFile::OnLongLineOn MutEditFile::OnFoldToggle MutEditFile::OnSetReadOnly MutEditFile::OnUseCharset MutEditFile::OnChangeCase MutEditFile::OnConvertEOL	EVT_MENU (CM_CONVERTCRLF, MutEditFile::OnConvertEOL) EVT_MENU(CM_CONVERTLF
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang MutEditFile::OnIndentGuide MutEditFile::OnLongLineOn MutEditFile::OnFoldToggle MutEditFile::OnSetReadOnly MutEditFile::OnUseCharset MutEditFile::OnChangeCase MutEditFile::OnConvertEOL MutEditFile::OnConvertEOL	EVT_STC_MARGINCLICK (wxID_ANY, MutEditFile::OnMarginClick) EVT_STC_CHARADDED(wxID_ANY
	BEGIN_EVENT_TABLE (MutFrame, wxDocChildFrame) EVT_ERASE_BACKGROUND(MutFrame
void	UpdateUIcallback (int box, bool logic_changed)
void	CheckBoxesUsed ()
	synchronizes `BoxUsed` with the routes
int	SmallestBoxUsed ()
	MutFrame::MutFrame (MutDocument doc, MutView v, wxFrame *frame, wxWindowID id, const wxString &title, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long type=wxDEFAULT_FRAME_STYLE, const wxString &name=wxT("Mutabor frame"))
virtual	MutFrame::~MutFrame ()
	Destructor.
void	MutFrame::PassEventToEditor (wxCommandEvent &event)
	passes an event to the editor.
void	MutFrame::EventPassOn (wxCommandEvent &event)
	passes an event to the MDI client window.
void	MutFrame::OnClose (wxCloseEvent &event)
	Handles close event.
void	MutFrame::OnPaint (wxPaintEvent &event)
	Hande paint events for Document/View framework.
void	MutFrame::CmFileNew (wxCommandEvent &WXUNUSED(event))
	This function creates a new file editor.
void	MutFrame::CmFileOpen (wxCommandEvent &WXUNUSED(event))
	Open an existing file if we don't have a client yet.
bool	MutFrame::OpenFile (wxString path, bool newfile=false)
	Opens the given file, if we don't have a client yet.
bool	MutFrame::SetClient (wxWindow *win, const wxString &title)
	Attach a client to the Frame.
void	MutFrame::CmDoActivate (wxCommandEvent &event)
	Get a file name to open static wxString FileNameDialog(wxWindow * parent);.
void	MutFrame::RaiseLogic (wxCommandEvent &event)
wxMenuItem *	MutFrame::ClearMenuItem (int id)
void	MutFrame::ClearSubMenu (wxMenuItem *item)
void	MutFrame::DoStop ()
void	MutFrame::CmStop (wxCommandEvent &WXUNUSED(event))
void	MutFrame::CmPanic (wxCommandEvent &WXUNUSED(event))
void	MutFrame::CeExecute (wxUpdateUIEvent &event)
void	MutFrame::CeActivate (wxUpdateUIEvent &event)
void	MutFrame::CeStop (wxUpdateUIEvent &event)
void	MutFrame::CmRoutes (wxCommandEvent &event)
void	MutFrame::CmToggleKey (wxCommandEvent &WXUNUSED(event))
void	MutFrame::CmToggleTS (wxCommandEvent &WXUNUSED(event))
void	MutFrame::CmToggleAct (wxCommandEvent &WXUNUSED(event))
void	MutFrame::CmToggleOWM (wxCommandEvent &WXUNUSED(event))
void	MutFrame::CmToggleCAW (wxCommandEvent &WXUNUSED(event))
void	MutFrame::CeToggleKey (wxUpdateUIEvent &event)
void	MutFrame::CeToggleTS (wxUpdateUIEvent &event)
void	MutFrame::CeToggleAct (wxUpdateUIEvent &event)
void	MutFrame::CeToggleOWM (wxUpdateUIEvent &event)
void	MutFrame::CeToggleCAW (wxUpdateUIEvent &event)
void	MutFrame::CmInDevStop (wxCommandEvent &WXUNUSED(event))
void	MutFrame::CmInDevPlay (wxCommandEvent &WXUNUSED(event))
void	MutFrame::CmInDevPause (wxCommandEvent &WXUNUSED(event))
void	MutFrame::StopInDev ()
void	MutFrame::CeInDevStop (wxUpdateUIEvent &event)
void	MutFrame::CeInDevPlay (wxUpdateUIEvent &event)
void	MutFrame::CeInDevPause (wxUpdateUIEvent &event)
void	MutFrame::CmSetTitle (wxCommandEvent &event)
void	MutFrame::UpdateUI (wxCommandEvent &WXUNUSED(event))
	Update GUI when the mutabor kernel or file players have acted.
void	MutFrame::OnEraseBackground (wxEraseEvent &event)
void	MutFrame::OnSize (wxSizeEvent &event)
wxAuiDockArt *	MutFrame::GetDockArt ()
void	MutFrame::WindowSize (MutChild *win)
void	MutFrame::SaveState ()
void	MutFrame::RestoreState ()
void	MutFrame::LogicWinOpen (int box)
void	MutFrame::ToggleTextBox (WinKind kind)
void	MutFrame::TextBoxOpen (WinKind kind, int box)
void	MutFrame::CmSelectBox ()
void	MutFrame::CmCloseChild ()
void	MutFrame::CloseAll (WinKind kind)
	Close all child windows of given kind.
void	MutFrame::SetStatus (int WXUNUSED(imgNr))
wxRect	MutFrame::DetermineFrameSize ()
bool	MutFrame::HasClient ()
	retrun true if we have already a client
void	MutFrame::UpdateBoxMenu ()
bool	MutFrame::RaiseTheFrame ()
static void	MutFrame::repaint_route ()
void	MutFrame::SetFileMenu (wxMenu *f)
void	MutFrame::SetEditMenu (wxMenu *e)
void	MutFrame::CloseClientWindow (wxWindow *w)
wxSize	MutTagSize (MUTTAGX, MUTTAGY)
	BEGIN_EVENT_TABLE (MutTag, wxWindow) EVT_PAINT(MutTag
	BEGIN_EVENT_TABLE (MutLogicWnd, wxScrolledWindow) EVT_CHAR(MutLogicWnd
	BEGIN_EVENT_TABLE (MutTextBox, wxListBox) EVT_CLOSE(MutTextBox
WinKind	operator++ (WinKind &k)
WinKind	operator++ (WinKind &k, int)
	WX_DECLARE_OBJARRAY (WinAttr, ArrayOfWinAttr)
	IMPLEMENT_DYNAMIC_CLASS (MutPanel, wxControl) BEGIN_EVENT_TABLE(MutPanel
wxControl	EVT_SIZE (MutPanel::OnSize) WX_EVENT_TABLE_CONTROL_CONTAINER(MutPanel) END_EVENT_TABLE() WX_DELEGATE_TO_CONTROL_CONTAINER(MutPanel
void	MutApp::OnInitCmdLine (wxCmdLineParser &parser)
	Initialize command line arguments.
bool	MutApp::OnCmdLineParsed (wxCmdLineParser &parser)
	Process command line arguments.
virtual bool	MutApp::ProcessEvent (wxEvent &event)
void	MutApp::PassEventToDocManagerCMD (wxCommandEvent &event)
	Pass event to document manager.
void	MutApp::PassEventToDocManagerUPD (wxUpdateUIEvent &event)
void	MutApp::OnMRUFile (wxCommandEvent &event)
	add handling of last files.
void	MutApp::CmAbout (wxCommandEvent &event)
	Display an about dialog box.
	AppAbout::AppAbout (wxWindow parent=(wxWindow ) NULL, long style=0)
	Constructor creating the window.
MutFrame *	MutApp::InitMainFrame (MenuType type, MutFrame *frame)
	Initialize a main frame.
void	MutApp::CmFileNew (wxCommandEvent &event)
	Create an editor file.
void	MutApp::CmFileOpen (wxCommandEvent &event)
	Open a new editor file.
void	MutApp::CmRoutes (wxCommandEvent &event)
	Open a new route editor.
void	MutApp::CmHelp (wxCommandEvent &event)
	Read help about a certain topic.
void	MutApp::ShowHelp (int commandId)
	Show the helpwindow on the page associated with a certain command id.
void	MutApp::CmQuit (wxCommandEvent &event)
	Exit the program.
static wxString	MutApp::GetResourceName (const wxString &file)
	Get a possibly localized resource file name.
wxMenu *	MutApp::MakeFileMenu (wxMenuBar *menuBar, MenuType type)
	Creates a file menu.
void	MutApp::MakeEditMenu (wxMenuBar *menuBar, MenuType type)
	Creates an edit menu.
void	MutApp::MakeLogicMenu (wxMenuBar *menuBar)
	Creates a mutabor logic menu.
void	MutApp::MakeRoutesMenu (wxMenuBar *menuBar)
	Creates a mutabor routes menu.
void	MutApp::MakeViewMenu (wxMenuBar *menuBar, MenuType type)
	Creates a View menu.
void	MutApp::MakeSequencerMenu (wxMenuBar *menuBar)
	Creates a mutabor sequencer menu.
void	MutApp::MakeHelpMenu (wxMenuBar *menuBar)
	Creates a mutabor help menu.
virtual int	MutApp::OnExit ()
	Callback for program quitting.
void	MutApp::SaveState ()
	Save global state.
void	MutApp::RestoreState ()
	Load global state.
static bool	MutToolBarBitmaps::Init ()
	MutChild::~MutChild ()
void	MutChild::OnActivate (wxActivateEvent &event)
void	MutChild::deleteFromWinAttrs ()
void	MutTag::InitText (wxDC &dc)
void	MutTag::OnChar (wxKeyEvent &event)
void	MutTag::OnLeftDown (wxMouseEvent &event)
void	MutTag::OnFocus (wxFocusEvent &event)
void	MutLogicWnd::doClose (wxEvent &event)
void	MutLogicWnd::OnChar (wxKeyEvent &event)
void	MutLogicWnd::CmTaste ()
void	MutLogicWnd::OnSize (wxSizeEvent &event)
void	MutLogicWnd::DoLayout ()
void	MutLogicWnd::CmMutTag (wxCommandEvent &event)
void	MutLogicWnd::CorrectScroller ()
void	MutLogicWnd::UpDate (int thekey, bool isLogicKey)
void	MutLogicWnd::CmBox ()
	MutTextBox::MutTextBox (WinKind k, WinAttr a, wxWindow parent=NULL, wxWindowID id=-1, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize)
void	MutTextBox::OnClose (wxCloseEvent &event)
void	MutTextBox::NewText (char *s, bool newTitle=false)
void	MutTextBox::NewText (wxString s, bool newTitle=false)
void	MutPanel::Init ()
bool	MutPanel::Create (wxWindow *parent, wxWindowID winid=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=0, const wxValidator &validator=wxDefaultValidator, const wxString &name=wxPanelNameStr)
virtual	MutPanel::~MutPanel ()
virtual void	MutPanel::InitDialog ()
void	MutPanel::OnSize (wxSizeEvent &event)
Variablen
wxHtmlHelpController *	HelpController = (wxHtmlHelpController *) NULL
MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD	wxID_FILE9
int	gs_nFrames = 0
ArrayOfWinAttr	WinAttrs [WK_NULL]
CompDlg *	CompDia = NULL
MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch	CM_HILIGHTLAST
MutFrame *	theFrame = 0
bool	demo = false
bool	asTS = true
bool	SaveEditor = true
bool	UseColorBars = true
bool	OWM = false
bool	CAW = false
bool	LogicOn = false
int	curBox = 0
wxWindow *	ChildToClose = NULL
wxString	CompiledFile
wxString	curLogic [MAX_BOX]
wxString	curTS [MAX_BOX]
int	curTaste [MAX_BOX][2]
bool	TextBoxWanted [MAX_BOX][3]
char	WinName [5][12] = { "KEYWIN", "TONSYSTWIN", "ACTIONWIN", "LOGICWIN", "ROUTEWIN" }
wxSize	subSize = wxDefaultSize
int	WSize [4][3]
bool	BoxUsed [MAX_BOX]
	which mutabor boxes are used at all?
wxMenu *	MutFrame::editmenu
wxMenu *	MutFrame::filemenu
int	MutFrame::curStatusImg
wxAuiManager	MutFrame::auimanager
wxWindow *	MutFrame::keywindows [MAX_BOX]
wxWindow *	MutFrame::tswindows [MAX_BOX]
wxWindow *	MutFrame::actionwindows [MAX_BOX]
wxWindow *	MutFrame::client
static MutFrame *	MutFrame::ActiveWindow
static int	MutFrame::boxCommandIds [MAX_BOX]
bool	asTS
bool	SaveEditor
bool	UseColorBars
bool	OWM
bool	CAW
bool	LogicOn
int	curBox
bool	BoxUsed [MAX_BOX]
	which mutabor boxes are used at all?
wxString	CompiledFile
wxString	curLogic [MAX_BOX]
wxString	curTS [MAX_BOX]
int	curTaste [MAX_BOX][2]
bool	TextBoxWanted [][3]
int	pubTaste
bool	UseColorBars
wxString	TextBoxTitle []
const wxChar	MutPanelNameStr []
static bool	MutToolBarBitmaps::initialized = false
static wxBitmap	MutToolBarBitmaps::New
static wxBitmap	MutToolBarBitmaps::Open
static wxBitmap	MutToolBarBitmaps::Save
static wxBitmap	MutToolBarBitmaps::SaveAs
static wxBitmap	MutToolBarBitmaps::Print
static wxBitmap	MutToolBarBitmaps::LogicActivate
static wxBitmap	MutToolBarBitmaps::LogicStop
static wxBitmap	MutToolBarBitmaps::LogicPanic
static wxBitmap	MutToolBarBitmaps::Copy
static wxBitmap	MutToolBarBitmaps::Cut
static wxBitmap	MutToolBarBitmaps::Paste
static wxBitmap	MutToolBarBitmaps::Undo
static wxBitmap	MutToolBarBitmaps::Redo
static wxBitmap	MutToolBarBitmaps::RouteLoad
static wxBitmap	MutToolBarBitmaps::RouteSave
static wxBitmap	MutToolBarBitmaps::IndevsPlay
static wxBitmap	MutToolBarBitmaps::IndevsStop
static wxBitmap	MutToolBarBitmaps::IndevsPause
static wxBitmap	MutToolBarBitmaps::About

Ausführliche Beschreibung

While the original frontend of Mutabor was designed using Borland OWL the current one uses the platform independent environment provided by wxWidgets.

Makro-Dokumentation

#define APPNAME _(PACKAGE_NAME)

Definiert in Zeile 305 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CmSetTitle() und MutFrame::OpenFile().

#define CLOSEMENU ( name ) menuBar->Append(menu, name);

Definiert in Zeile 282 der Datei MutFrame.cpp.

#define Compiled (!CompiledFile.IsEmpty())

Definiert in Zeile 354 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CmDoActivate().

#define max	(	a,
		b
	)	((a) < (b) ? (b) : (a))

Definiert in Zeile 502 der Datei MutLogicWnd.cpp.

Wird benutzt von RouteRemoveButton::Create(), MutIconShape::DoGetBestSize(), BoxDlg::DoGetBestSize(), MutLogicWnd::DoLayout(), MutInputMidiFileDeviceShape::GetInputFilterPanel(), MutInputMidiDeviceShape::GetInputFilterPanel(), MutInputGuidoFileDeviceShape::GetInputFilterPanel(), MutOutputMidiFileDeviceShape::GetOutputFilterPanel(), MutOutputMidiDeviceShape::GetOutputFilterPanel() und hoechste_taste().

#define MENUCHECKITEM	(	name,
		id,
		help
	)	menu->AppendCheckItem(id, name, help)

Definiert in Zeile 288 der Datei MutFrame.cpp.

#define MENUITEM	(	name,
		id,
		help
	)	menu->Append(id, name, help)

Definiert in Zeile 285 der Datei MutFrame.cpp.

#define MENUITEM_ADD	(	name,
		id,
		help,
		add
	)	menu->Append(id, name, help, add)

Definiert in Zeile 291 der Datei MutFrame.cpp.

#define MENUITEM_SEPARATOR menu->AppendSeparator()

Definiert in Zeile 294 der Datei MutFrame.cpp.

#define MUTTAGX 90

Definiert in Zeile 77 der Datei MutLogicWnd.cpp.

Wird benutzt von MutLogicWnd::CorrectScroller(), MutLogicWnd::DoLayout(), MutTag::InitText() und MutTag::PaintCenteredText().

#define MUTTAGY 70

Definiert in Zeile 78 der Datei MutLogicWnd.cpp.

Wird benutzt von MutLogicWnd::CorrectScroller() und MutLogicWnd::DoLayout().

#define OPENMENU menu = new wxMenu;

Definiert in Zeile 279 der Datei MutFrame.cpp.

#define PACKAGE_NAME "Mutabor"

Definiert in Zeile 302 der Datei MutFrame.cpp.

Wird benutzt von AppAbout::AppAbout(), IMPLEMENT_APP() und mutabor::MutDocManager::MakeFrameTitle().

#define SG_LOGIC 0

Definiert in Zeile 349 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CmDoActivate().

#define SG_NOTHING 1

Definiert in Zeile 348 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::DoStop().

#define SG_PAUSE 4

Definiert in Zeile 352 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CeInDevPause() und MutFrame::CmInDevPause().

#define SG_PLAY 3

Definiert in Zeile 351 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CeInDevPause() und MutFrame::CmInDevPlay().

#define SG_RECORD 2

Definiert in Zeile 350 der Datei MutFrame.cpp.

Dokumentation der Aufzählungstypen

enum WinKind

Aufzählungswerte:

WK_KEY
WK_TS
WK_ACT
WK_LOGIC
WK_ROUTE
WK_EDIT
WK_NULL

Definiert in Zeile 38 der Datei MutTextBox.h.

{ WK_KEY = 0, WK_TS, WK_ACT, WK_LOGIC, WK_ROUTE, WK_EDIT, WK_NULL };

Dokumentation der Funktionen

AppAbout::AppAbout	(	wxWindow *	parent = `(wxWindow *) NULL`,
		long	style = `0`
	)

Constructor creating the window.

Parameter:

parent	Parent window
style	Dialog style of about window

Definiert in Zeile 600 der Datei MutApp.cpp.

Benutzt _(), Get() und PACKAGE_NAME.

                : wxDialog (parent, -1, wxEmptyString,
                            wxDefaultPosition, wxDefaultSize,
                            wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
{

        // setup path
        wxStandardPathsBase &path = wxStandardPaths::Get();


        // sets the application icon
        SetTitle (_("About ..."));

        // about info
        wxGridSizer *aboutinfo = new wxFlexGridSizer (2, 5, 5);
        aboutinfo->Add (new wxStaticText(this, -1, _("Version: ")));
        aboutinfo->Add (new wxStaticText(this, -1, _T(PACKAGE_VERSION)));
        aboutinfo->Add (new wxStaticText(this, -1, _("Written by: ")));
        aboutinfo->Add (new wxStaticText(this, -1, _("Bernhard Ganter\n"
                                         "Volker Abel\n"
                                         "Peter Reiss\n"
                                         "Ruediger Krausze <krausze@mail.berlios.de>\n"
                                         "Tobias Schlemmer <keinstein@mail.berlios.de>")));
        aboutinfo->Add (new wxStaticText(this, -1, _("Mathematical\nmodelling:")));
        aboutinfo->Add (new wxStaticText(this, -1, _("Rudolf Wille")));
        aboutinfo->Add (new wxStaticText(this, -1, _("Licence type: ")));
        aboutinfo->Add (new wxStaticText(this, -1, _("GPL")));
        aboutinfo->Add (new wxStaticText(this, -1, _("wxWidgets: ")));
        aboutinfo->Add (new wxStaticText(this, -1, wxVERSION_STRING));
        aboutinfo->Add (new wxStaticText(this, -1, _("Copyright: ")));
        aboutinfo->Add (new wxStaticText(this, -1, _("(c) 2007 TU Dresden, Institut fuer Algebra")));

        // about title/info
        wxBoxSizer *abouttext = new wxBoxSizer (wxVERTICAL);
//    wxStaticText *appname = new wxStaticText (this, -1, g_appname);
        wxStaticText * appname = new wxStaticText (this, -1, mumT(PACKAGE_NAME));
        appname->SetFont (wxFont (10, wxDEFAULT, wxNORMAL, wxBOLD));
        abouttext->Add (appname, 0, wxALIGN_LEFT);
        abouttext->Add (0, 10);
        abouttext->Add (aboutinfo, 1, wxEXPAND);

        // about icontitle//info
        wxBoxSizer *aboutpane = new wxBoxSizer (wxHORIZONTAL);
//    wxBitmap bitmap = wxBitmap(wxICON (mutabor));
        wxBitmap bitmap = wxBitmap(wxFileName(path.GetResourcesDir(),_T("about"),_T("png")).GetFullPath(),
                                   wxBITMAP_TYPE_PNG);
        aboutpane->Add (new wxStaticBitmap (this, -1, bitmap),
                        0, wxALIGN_LEFT);
        aboutpane->Add (10, 0);
        aboutpane->Add (abouttext, 1, wxEXPAND);

        // about complete
        wxBoxSizer *totalpane = new wxBoxSizer (wxVERTICAL);
        totalpane->Add (aboutpane, 0, wxEXPAND | wxALL, 10);
        totalpane->Add (new wxStaticText(this, -1, _("Mutabor tuning")),
                        0, wxALIGN_CENTER | wxLEFT | wxRIGHT, 10);
        totalpane->Add (0, 6);
//    myHyperLink *website = new myHyperLink (this, -1, APP_WEBSITE);
//    wxString url = APP_WEBSITE;
//    url.Append ("/indexedit.html");
//    website->SetURL (url);
//    totalpane->Add (website, 0, wxALIGN_CENTER);
//      totalpane->Add (new wxStaticLine(this, -1), 0, wxEXPAND | wxALL, 10);
        wxButton *okButton = new wxButton (this, wxID_OK, _("OK"));
        okButton->SetDefault();
        totalpane->Add (okButton, 0, wxALIGN_CENTER | wxLEFT | wxRIGHT | wxBOTTOM, 10);

        SetSizerAndFit (totalpane);

        ShowModal();
}

BEGIN_EVENT_TABLE	(	MutConfigDialog	,
		ConfigDlg
	)

Definiert in Zeile 540 der Datei MutApp.cpp.

{

        MutConfigDialog * config;
        config = new MutConfigDialog((wxFrame *) NULL);

        if (config) {
                int value = config->ShowModal();
                config->Destroy();
        }
}

BEGIN_EVENT_TABLE	(	MutApp	,
		wxApp
	)

BEGIN_EVENT_TABLE	(	MutChild	,
		MutTextBox
	)

Definiert in Zeile 85 der Datei MutChild.cpp.

Benutzt DEBUGLOG, WK_KEY und WK_NULL.

                                        :
                MutTextBox(k,attr,parent,id,pos,size)
//#ifdef MDI_FORCE_EXTERN
//       : wxAuiPaneInfo()

//#else
//       : wxMDIChildFrame(parent, wxID_ANY, title, wxDefaultPosition, wxDefaultSize,
//                         wxDEFAULT_FRAME_STYLE | wxNO_FULL_REPAINT_ON_RESIZE,title)
//#endif
{
        DEBUGLOG (other, _T("winKind=%d"),winKind);
        wxASSERT(WK_KEY <= winKind && winKind < WK_NULL);
        winAttr->Win = this;
        DEBUGLOG (other, _T("winKind=%d"),winKind);
}

BEGIN_EVENT_TABLE	(	MutFrame	,
		wxDocChildFrame
	)

Definiert in Zeile 362 der Datei MutFrame.cpp.

Benutzt _().

                                    : wxDocChildFrame(NULL, 
                                                      NULL, 
                                                      parent, 
                                                      id, 
                                                      title, 
                                                      pos, 
                                                      size,
                                                      style | wxNO_FULL_REPAINT_ON_RESIZE),
        curStatusImg(0)
{

        SetSize (DetermineFrameSize ());
        client = NULL;
        editmenu = filemenu = NULL;

        auimanager.SetManagedWindow(this);


#if wxUSE_TOOLBAR
        wxToolBar * tb = new  wxToolBar(this,
                                        wxID_ANY,
                                        wxDefaultPosition,
                                        wxDefaultSize,
                                        wxTB_DOCKABLE);
        InitToolBar(tb);

        auimanager.AddPane(tb, wxAuiPaneInfo().
                           Name(_T("tb")).Caption(_("Toolbar")).
                           ToolbarPane().Top().
                           LeftDockable(false).RightDockable(false));
#endif // wxUSE_TOOLBAR


        // Accelerators
        /*    wxAcceleratorEntry entries[3];
            entries[0].Set(wxACCEL_CTRL, (int) 'N', MDI_NEW_WINDOW);
            entries[1].Set(wxACCEL_CTRL, (int) 'X', MDI_QUIT);
            entries[2].Set(wxACCEL_CTRL, (int) 'A', MDI_ABOUT);
            wxAcceleratorTable accel(3, entries);
            SetAcceleratorTable(accel);*/
}

BEGIN_EVENT_TABLE	(	MutEditFile	,
		wxStyledTextCtrl
	)

BEGIN_EVENT_TABLE	(	MutTag	,
		wxWindow
	)

Definiert in Zeile 140 der Datei MutLogicWnd.cpp.

                : wxWindow(parent, CM_MUTTAG, pos, MutTagSize)
{
        /*  int Types[4] = { IDI_TONSYST, IDI_LOGIC, IDI_TONSYSTOPEN, IDI_LOGICOPEN};
          Attr.Style |= BS_OWNERDRAW | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS
                                 | WS_GROUP | WS_TABSTOP;
          Icon = new TIcon(GetModule()->GetInstance(), (TResId)Types[isLogic + 2*isOpen]);*/
        //      SetBackgroundColour(*wxWHITE);

        const char  ** TagIcon[4] = {
                                            tonesyst_xpm, logic_xpm, tonesystopen_xpm, logicopen_xpm
                                    };

        Icon = wxIcon(TagIcon[isLogic + 2*isOpen]);
        Text = text;
        TPos = -1;
        IsLogic = isLogic;
        Key = key;

//TODO  Attr.AccelTable = IDA_MUTWIN;
}

BEGIN_EVENT_TABLE	(	MutLogicWnd	,
		wxScrolledWindow
	)

Definiert in Zeile 362 der Datei MutLogicWnd.cpp.

Benutzt GetWinAttr() und WK_LOGIC.

                : wxScrolledWindow(parent, -1, pos, size, wxHSCROLL | wxVSCROLL | wxTAB_TRAVERSAL)
{
#ifdef DEBUG
        std::cout << "MutLogicWnd::MutLogicWnd: Box " <<  box << std::endl;
#endif
        /*  TWindow::Attr.Style |= WS_GROUP | WS_CLIPCHILDREN|
                                        WS_CLIPSIBLINGS | WS_VSCROLL | WS_HSCROLL | WS_BORDER;
          Scroller = new TScroller(this, 8, 7, 8, 7);*/
        boxnumber = box;
        ColorBar1 = 0;
        ColorBar2 = 0;
        /*  Attr.AccelTable = IDA_MUTWIN;*/
        SetScrollRate( 10, 10 );
        SetBackgroundColour(*wxWHITE);
        Ok = false;
        CmBox();

        winAttr = GetWinAttr(WK_LOGIC,box);
        wxASSERT(!winAttr->Win);
        winAttr->Win = this;
}

BEGIN_EVENT_TABLE	(	MutTextBox	,
		wxListBox
	)

Definiert in Zeile 55 der Datei MutTextBox.cpp.

Benutzt _().

                       { _("<init>") };

void MutFrame::CeActivate ( wxUpdateUIEvent & event )

Definiert in Zeile 1117 der Datei MutFrame.cpp.

Benutzt MutFrame::client und LogicOn.

{
        //      event.Enable(!LogicOn && (Compiled || ActiveWinKind == WK_EDIT));
        event.Enable(!LogicOn && (dynamic_cast<MutEditFile *>(client)));
}

void MutFrame::CeExecute ( wxUpdateUIEvent & event )

Definiert in Zeile 1110 der Datei MutFrame.cpp.

Benutzt LogicOn.

{
        //      event.Enable(!LogicOn && (Compiled || ActiveWinKind == WK_EDIT));
        event.Enable(!LogicOn);
}

void MutFrame::CeInDevPause ( wxUpdateUIEvent & event )

Definiert in Zeile 1740 der Datei MutFrame.cpp.

Benutzt MutFrame::curStatusImg, DTMidiFile, InDevice::GetDeviceList(), InDevice::GetNext(), LogicOn, MutaborDevicePause, MutaborDevicePlay, MutFrame::SetStatus(), SG_PAUSE und SG_PLAY.

{
  bool Pause = 0;
  
  for ( InDevice *In = InDevice::GetDeviceList(); In; In = In->GetNext())
    if ( In->GetType() >= DTMidiFile ) {
      if ( In->GetMode() == MutaborDevicePlay ) {
        event.Enable(true);
        
        if ( curStatusImg != SG_PLAY )
          SetStatus(SG_PLAY);
        
        return;
      } else if ( In->GetMode() == MutaborDevicePause )
        Pause = true;
    }
  if ( Pause ) {
    if ( curStatusImg != SG_PAUSE )
      SetStatus(SG_PAUSE);
  } else if ( curStatusImg != 1-LogicOn )
    SetStatus(1-LogicOn);
  
  event.Enable(false);
}

void MutFrame::CeInDevPlay ( wxUpdateUIEvent & event )

Definiert in Zeile 1711 der Datei MutFrame.cpp.

Benutzt DEBUGLOG, DTMidiFile, InDevice::GetDeviceList(), InDevice::GetNext(), LogicOn, MutaborDevicePause und MutaborDeviceStop.

{
  if ( !LogicOn ) {
    DEBUGLOG (other, _T("Logic is off"));
    event.Enable(false);
    return;
  }

  for ( InDevice *In = InDevice::GetDeviceList(); In; In = In->GetNext()) {
    DEBUGLOG (routing, _T("checking Device type %d >= %d with mode %d for pointer %p"),
              In->GetType(),
              DTMidiFile,
              In->GetMode(),
              In);

    if ( In->GetType() >= DTMidiFile &&
         (In->GetMode() == MutaborDeviceStop ||
          In->GetMode() == MutaborDevicePause) ) {
      DEBUGLOG (other, _T("Device can be activated"));
      event.Enable(true);
      return;
    }
    
    DEBUGLOG (other, _T("Device can not be activated"));
  }

  event.Enable(false);
}

void MutFrame::CeInDevStop ( wxUpdateUIEvent & event )

Definiert in Zeile 1699 der Datei MutFrame.cpp.

Benutzt DTMidiFile, InDevice::GetDeviceList(), InDevice::GetNext(), MutaborDevicePause und MutaborDevicePlay.

{
  for ( InDevice *In = InDevice::GetDeviceList(); In; In = In->GetNext())
    if ( In->GetType() >= DTMidiFile &&
         (In->GetMode() == MutaborDevicePlay ||
          In->GetMode() == MutaborDevicePause) ) {
      event.Enable(true);
      return;
    }
  event.Enable(false);
}

void MutFrame::CeStop ( wxUpdateUIEvent & event )

Definiert in Zeile 1123 der Datei MutFrame.cpp.

Benutzt LogicOn.

{
        event.Enable(LogicOn);
}

void MutFrame::CeToggleAct ( wxUpdateUIEvent & event )

Definiert in Zeile 1422 der Datei MutFrame.cpp.

Benutzt curBox, TextBoxWanted und WK_ACT.

{
        event.Check(TextBoxWanted[curBox][WK_ACT]);
}

void MutFrame::CeToggleCAW ( wxUpdateUIEvent & event )

Definiert in Zeile 1432 der Datei MutFrame.cpp.

Benutzt CAW.

{
        event.Check(CAW);
}

void MutFrame::CeToggleKey ( wxUpdateUIEvent & event )

Definiert in Zeile 1412 der Datei MutFrame.cpp.

Benutzt curBox, TextBoxWanted und WK_KEY.

{
        event.Check(TextBoxWanted[curBox][WK_KEY]);
}

void MutFrame::CeToggleOWM ( wxUpdateUIEvent & event )

Definiert in Zeile 1427 der Datei MutFrame.cpp.

Benutzt OWM.

{
        event.Check(OWM);
}

void MutFrame::CeToggleTS ( wxUpdateUIEvent & event )

Definiert in Zeile 1417 der Datei MutFrame.cpp.

Benutzt curBox, TextBoxWanted und WK_TS.

{
        event.Check(TextBoxWanted[curBox][WK_TS]);
}

void CheckBoxesUsed ( )

synchronizes BoxUsed with the routes

Definiert in Zeile 1993 der Datei MutFrame.cpp.

Benutzt InDevice::GetDeviceList(), Route::GetNext(), InDevice::GetNext(), MAX_BOX, ERoute::Next, EDevice::Next, EDevice::Routes und UNREACHABLE.

{
        for (int i = 0; i < MAX_BOX; i++)
                BoxUsed[i] = false;

        for (InDevice *In = InDevice::GetDeviceList(); In; In = In->GetNext())
          for (Route *R = In->GetRoutes(); R; R = R->GetNext())
            if ( R->Box >= 0 ) {
              if (R->Box >= MAX_BOX) UNREACHABLE;
              else
                BoxUsed[R->Box] = true;
            }
}

wxMenuItem * MutFrame::ClearMenuItem ( int id )

Definiert in Zeile 986 der Datei MutFrame.cpp.

Benutzt MutFrame::ClearSubMenu().

Wird benutzt von MutFrame::DoStop() und MutFrame::UpdateBoxMenu().

{
        wxMenuItem * item = GetMenuBar()->FindItem(id);

        if (item->IsSubMenu())
                ClearSubMenu(item);

        return item;
}

void MutFrame::ClearSubMenu ( wxMenuItem * item )

Definiert in Zeile 996 der Datei MutFrame.cpp.

Benutzt DEBUGLOG.

Wird benutzt von MutFrame::ClearMenuItem().

{

        wxMenu * menu = item->GetSubMenu();
#ifdef DEBUG
        DEBUGLOG (other, _T("item: %s\n"),(item->GetText()).c_str())
        std::cerr << " (" << item << ")" << std::endl;
#endif

        if (! menu) return;

        menu->AppendSeparator(); // just to make sure, the item group is finished.


        wxMenuItemList& l = menu->GetMenuItems();

        DEBUGLOG (other, _T(" %d items"),l.GetCount());

        for (wxMenuItemList::iterator i = l.begin(); i!=l.end(); i=l.begin()) {
                wxMenuItem * node = *i;
                DEBUGLOG (other, _T("ptr %x handling %s"), node,(node->GetText()).c_str());

                if (node->IsSubMenu())
                        ClearSubMenu(node);

                Disconnect(node->GetId(),wxEVT_COMMAND_MENU_SELECTED);

                DEBUGLOG (other, _T("destroying %s"),(node->GetText()).c_str());

                //    node->GetNext();
                menu->Destroy(node);
        }
}

void MutFrame::CloseAll ( WinKind kind )

Close all child windows of given kind.

This function closes all child windows of the given kind.

Parameter:

kind	any wk_kind, that describes which kind of windows shall be closed.

Definiert in Zeile 1913 der Datei MutFrame.cpp.

Benutzt _(), MutFrame::auimanager, MutFrame::CloseClientWindow(), DEBUGLOG, muT, WinAttr::Wanted, WinAttr::Win und WinAttrs.

Wird benutzt von MutFrame::DoStop().

{
        DEBUGLOG (other, _T(""));

        auimanager.Update();

        for (size_t i = WinAttrs[kind].Count(); i >0; i--) {
                DEBUGLOG (other, _T("kind %d (%d of %d)"),kind,i,WinAttrs[kind].Count());
                WinAttr &win = WinAttrs[kind].Item(i-1);

                if ( win.Win ) {
                        DEBUGLOG (other, _("Closing window of class %s"), muT(typeid(*(win.Win)).name()).c_str());
                        win.Wanted = 2;

                        CloseClientWindow(win.Win);
                        DEBUGLOG (other, _T("Returned."));
                }
        }
}

void MutFrame::CloseClientWindow ( wxWindow * w ) [inline, private]

Definiert in Zeile 355 der Datei MutFrame.h.

Benutzt MutFrame::auimanager und DEBUGLOG.

Wird benutzt von MutFrame::CloseAll().

        {
                wxASSERT(w);
                if (!w) return;

                w->Disable();
                auimanager.ClosePane(auimanager.GetPane(w));
                DEBUGLOG(other, _T("Detaching pane."));
                auimanager.DetachPane(w);
                auimanager.Update();

                DEBUGLOG(other, _T("Closing window."));
                w->Close(); // win should be invalid now.
        }

void MutApp::CmAbout ( wxCommandEvent & event )

Display an about dialog box.

Definiert in Zeile 556 der Datei MutApp.cpp.

Benutzt _() und Get().

{

        /*
          (void)wxMessageBox(wxString::Format(_("%s\nAuthors: \n%s\nUsage: %s"),
                                              mumT(PACKAGE_STRING),
                                              _T("Ruediger Krausze <krausze@mail.berlios.de>\n")
                                              _T("Tobias Schlemmer <keinstein@mail.berlios.de>\n"),
                                              mumT(PACKAGE)),
                             wxString::Format(_("About %s"),mumT(PACKAGE_NAME)));
        */
        /*      AppAbout * about;
                about = new AppAbout((wxFrame *) NULL);
                about->Destroy();

        */
        // setup path
        wxStandardPathsBase &path = wxStandardPaths::Get();
        wxAboutDialogInfo info;
        info.SetCopyright(_("(c) 2005-2011 TU Dresden"));
        info.SetVersion(_T(PACKAGE_VERSION));
        info.SetWebSite(_T("http://www.math.tu-dresden.de/~mutabor/"));
        info.SetIcon(wxIcon(wxFileName(path.GetResourcesDir(),
                                       _T("about"),
                                       _T("png")).GetFullPath(),
                            wxBITMAP_TYPE_PNG));
        info.SetDescription(_("An application to implement different tuning logics.\n Both fixed, adaptive and mutable tunings are supported."));
        info.AddArtist(_("Rudolf Wille (mathematical foundation)"));
        info.AddArtist(_("Tobias Schlemmer (new icon/splash)"));
        info.AddDeveloper(_("Bernhard Ganter"));
        info.AddDeveloper(_("Volker Abel"));
        info.AddDeveloper(_("Peter Reiss"));
        info.AddDeveloper(_("Ruediger Krausze <krausze@mail.berlios.de>"));
        info.AddDeveloper(_("Tobias Schlemmer <keinstein@mail.berlios.de>"));
        info.AddDocWriter(_("Volker Abel"));
        info.AddDocWriter(_("Peter Reiss"));
        info.AddDocWriter(_("Ruediger Krausze <krausze@mail.berlios.de>"));
        info.AddDocWriter(_("Tobias Schlemmer <keinstein@mail.berlios.de>"));
        info.AddTranslator(_("English: Tobias Schlemmer"));

        wxGenericAboutBox(info);
}

void MutLogicWnd::CmBox ( )

Definiert in Zeile 695 der Datei MutLogicWnd.cpp.

Benutzt _(), MutLogicWnd::boxnumber, CompiledFile, DEBUGLOG und MutLogicWnd::UpDate().

{
        DEBUGLOG (other, _T("%s at box %d"),CompiledFile.c_str(),boxnumber );
        // Titel setzen
        GetParent()->SetName(wxString::Format(_("Logic: %s - Box %d"),
                                              CompiledFile.c_str(), boxnumber));
        // Tags updaten
        UpDate(0, true);
}

void MutFrame::CmCloseChild ( )

Definiert in Zeile 1456 der Datei MutFrame.cpp.

Benutzt ChildToClose.

{
        if ( ChildToClose )
                ChildToClose->Close();
}

void MutFrame::CmDoActivate ( wxCommandEvent & event )

Get a file name to open static wxString FileNameDialog(wxWindow * parent);.

Definiert in Zeile 850 der Datei MutFrame.cpp.

Benutzt _(), Activate(), AktionTraceReset(), BoxUsed, CheckBoxesUsed(), CheckNeedsRealTime(), Compiled, curBox, curLogic, curTaste, curTS, DEBUGLOG, DontWant(), LogicOn, MAX_BOX, OWM, RealTime, MutFrame::repaint_route(), SetAktuellesKeyboardInstrument(), MutFrame::SetStatus(), SG_LOGIC, MutFrame::TextBoxOpen(), TextBoxWanted, MutFrame::UpdateBoxMenu(), UpdateUIcallback(), WinAttrs, WK_ACT, WK_KEY, WK_LOGIC, WK_NULL und WK_ROUTE.

Wird benutzt von MutFrame::CmInDevPlay().

{
        if (LogicOn) return;

#ifdef DEBUG
        std::cout << "MutFrame::CmDoActivate" << std::endl;
#endif

        if ( !Compiled )
                return;

        wxGetApp().SaveState();

#ifdef DEBUG
        DEBUGLOG (other, _T("Restoring state for debugging"));
        wxGetApp().RestoreState();
#endif

//      ScanDevices(); 

        AktionTraceReset();

        // aktivieren
#ifndef NOACTIVATE
#ifdef DEBUG
        std::cerr << "MutFrame::CmDoActivate: Activate" << std::endl;

#endif
        RealTime = true;

        if ( !CheckNeedsRealTime() )
                RealTime = (wxMessageBox(_("There are no realtime \
                                           instruments in the routes.\n\
                                           Shall Mutabor translate the files in batch mode, \
                                           to keep the MIDI files with the original time stamp?\n\
                                           (This means also, that you can't modify the tunings \
                                           while playing by computer keyboard.)"),
                                         _("No realtime => batch mode?"),
                                         wxYES_NO | wxICON_QUESTION
                                         /*| MB_DEFBUTTON2*/) == wxNO);

        theFrame = this;

        if ( !Activate(RealTime, &UpdateUIcallback) )
                return;

#endif

#ifdef DEBUG
        std::cerr << "MutFrame::CmDoActivate: Initialize state" << std::endl;

#endif

        // Variablen initialisieren
        for (int instr = 0; instr < MAX_BOX; instr++) {
                curLogic[instr] = _T("(INITIAL)");
                curTS[instr] = _T("0");
                curTaste[instr][0] = 0;
                curTaste[instr][1] = 0;
        }

#ifdef DEBUG
        std::cout << "MutFrame::CmDoActivate: Check used boxes" << std::endl;

#endif
        // curBox checken
        CheckBoxesUsed();

        if ( !BoxUsed[curBox] ) {
                curBox = 0;

                for (int i = 0; i < MAX_BOX; i++)
                        if ( BoxUsed[i] ) {
                                curBox = i;
                                break;
                        }
        }

        SetAktuellesKeyboardInstrument(curBox);

        // WinAttrs säubern
        DEBUGLOG (other, _T("Clear window attributes"));

        for (WinKind kind = WK_KEY; kind < WK_NULL; kind++) {
                size_t i;

                while ( (i = WinAttrs[kind].GetCount()) > 0)
                        if ( !BoxUsed[WinAttrs[kind][i].Box] )
                                WinAttrs[kind].RemoveAt(i);
        }

        DEBUGLOG (other, _T("Open other than logic; One window mode: %d"),OWM);

        // set windows except curBox setzen
        if ( !OWM )
                for (WinKind kind = WK_KEY; kind < WK_LOGIC; kind++)
                        for (size_t i = 0; i < WinAttrs[kind].GetCount(); i++)
                                if ( WinAttrs[kind][i].Box != curBox
                                                &&  WinAttrs[kind][i].Wanted )
                                        TextBoxOpen(kind, WinAttrs[kind][i].Box);

        UpdateBoxMenu();
        MutFrame * routewin = dynamic_cast<MutFrame *>(FindWindowById(WK_ROUTE));
        if ( routewin ) routewin->UpdateBoxMenu();
        DEBUGLOG (other, _T("Open Logic window"));
        // curBox-Fenstersetzen
        //  LogicWinOpen(curBox);
        LogicOn = true;

        // Toolbar
        /*2     ControlBar->Remove(*ButtonActivate);
        ControlBar->Insert(*ButtonStop, TGadgetWindow::Before, ButtonPanic);
        ControlBar->LayoutSession();*/
        // Statusbar
        SetStatus(SG_LOGIC);

        DEBUGLOG (other, _T("Open Text boxes: %d -- %d"),WK_KEY,WK_ACT);

        for (size_t i = 0; i < MAX_BOX; i++)
                if (BoxUsed[i])
                        for (WinKind kind = WK_KEY; kind <= WK_ACT; kind++) {
                                if ( TextBoxWanted[i][kind] )
                                        TextBoxOpen(kind, i);
                                else
                                        DontWant(kind, i);
                        }


        DEBUGLOG (other, _T("Repaint route"));

        repaint_route();

        DEBUGLOG (other, _T("event.Skip()"));
        event.Skip(false);
}

void MutApp::CmFileNew ( wxCommandEvent & event )

Create an editor file.

Definiert in Zeile 800 der Datei MutApp.cpp.

Benutzt MutFrame::CmFileNew(), MutApp::CreateMainFrame(), MutApp::EditorMenu und MutApp::MustOpenFrame().

{
#ifdef DEBUG
        printf("MutApp::CmFileNew\n");
#endif
        MutFrame * frame = dynamic_cast<MutFrame*>(GetTopWindow());

        if (MustOpenFrame(frame))
                frame = CreateMainFrame(EditorMenu);

#ifdef DEBUG
        printf("MutApp::CmFileNew: created main frame\n");

#endif
        frame->CmFileNew(event);
        frame->Show();

#ifdef DEBUG
        printf("MutApp::CmFileNew: file new: done.\n");

#endif
        event.Skip(false);
}

void MutFrame::CmFileNew ( wxCommandEvent & WXUNUSEDevent )

This function creates a new file editor.

Handle new file event if we don't have a client yet.

Definiert in Zeile 708 der Datei MutFrame.cpp.

Benutzt MutFrame::client, MutFrame::OpenFile() und STUBC.

Wird benutzt von MutApp::CmFileNew().

{
        STUBC;
        return;

#ifdef DEBUG
        printf("MutFrame::CmFileNew\n");
#endif

        if (client) {
                event.Skip(true);
                return ;
        }

        event.Skip(false); // Its our task to try create the file

        OpenFile(wxEmptyString);
}

void MutApp::CmFileOpen ( wxCommandEvent & event )

Open a new editor file.

Definiert in Zeile 825 der Datei MutApp.cpp.

Benutzt CM_ACTIVATE, CM_EXECUTE, MutApp::CreateMainFrame(), MutApp::EditorMenu, FileNameDialog(), MutApp::MustOpenFrame() und MutFrame::OpenFile().

{
        wxWindow * topwindow=GetTopWindow();

        event.Skip(false);

        wxString path = FileNameDialog(topwindow);

        MutFrame * frame = dynamic_cast<MutFrame*>(topwindow);

        if ( !path )
                return;

        if (MustOpenFrame(frame)) 
                frame = CreateMainFrame(EditorMenu);

        frame->OpenFile(path);

#ifdef DEBUG
        std::cerr << "MutApp:CmFileOpen " << CM_EXECUTE << " == "
        << event.GetId() << "?" << std::endl;

#endif

        switch (event.GetId()) {

        case CM_EXECUTE:
                wxCommandEvent e(wxEVT_COMMAND_MENU_SELECTED,CM_ACTIVATE);

                wxPostEvent(frame,e);

                break;
        }
        frame->Show();

}

void MutFrame::CmFileOpen ( wxCommandEvent & WXUNUSEDevent )

Open an existing file if we don't have a client yet.

Definiert in Zeile 728 der Datei MutFrame.cpp.

Benutzt _(), MutFrame::client, CM_ACTIVATE, CM_EXECUTE, CM_FILEOPEN, CM_FILESAVEAS, FileNameDialog(), MutFrame::OpenFile(), MutFrame::PassEventToEditor() und STUBC.

{
        STUBC;
        return;

        if (client) {
                event . Skip (true);
                return;
        }

        event . Skip (false); // it's our task to try to open that file

        wxString path = FileNameDialog(this, event.GetId());

        if ( !path )
                return;


#ifdef DEBUG
        std::cerr << "MutFrame:CmFileOpen " << CM_EXECUTE << " == "
        << event . GetId () << "?" << std::endl;

#endif


        switch (event.GetId()) {

        case CM_FILEOPEN:
                OpenFile(path);

                break;

        case CM_EXECUTE: {
                OpenFile(path);
                wxCommandEvent e (wxEVT_COMMAND_MENU_SELECTED, CM_ACTIVATE);
                ProcessEvent (e);
        }

        break;

        case CM_FILESAVEAS:
                event.SetString(path);

                PassEventToEditor(event);

                break;

        default:
                wxLogError(_("Unexpected Event in MutFrame::CmFileOpen: %d"),event.GetId());
        }
}

void MutApp::CmHelp ( wxCommandEvent & event )

Read help about a certain topic.

Definiert in Zeile 890 der Datei MutApp.cpp.

Benutzt MutApp::ShowHelp().

{
        ShowHelp(event.GetId());
        event.Skip();
}

void MutFrame::CmInDevPause ( wxCommandEvent & WXUNUSEDevent )

Definiert in Zeile 1683 der Datei MutFrame.cpp.

Benutzt InDevice::GetDeviceList(), InDevice::GetNext(), MutaborDevicePlay, MutFrame::repaint_route(), MutFrame::SetStatus() und SG_PAUSE.

{
  int nr = 0;

  for ( InDevice *In = InDevice::GetDeviceList(); In; In = In->GetNext(), nr++)
    if ( In->GetMode() == MutaborDevicePlay ) {
      //                        In->Mode = MutaborDevicePause;
      //                InDeviceAction(nr, In->Mode);
      In->Pause();
    }
  
  repaint_route();
  
  SetStatus(SG_PAUSE);
}

void MutFrame::CmInDevPlay ( wxCommandEvent & WXUNUSEDevent )

Definiert in Zeile 1661 der Datei MutFrame.cpp.

Benutzt MutFrame::CmDoActivate(), DEBUGLOG, InDevice::GetDeviceList(), InDevice::GetNext(), LogicOn, MutaborDevicePause, MutaborDeviceStop, MutFrame::repaint_route(), MutFrame::SetStatus() und SG_PLAY.

{
        DEBUGLOG (other, _T(""));

        if ( !LogicOn )
                CmDoActivate(event);

        int nr = 0;

        for ( InDevice *In = InDevice::GetDeviceList(); In; In = In->GetNext(), nr++)
          if ( In->GetMode() == MutaborDeviceStop ||
               In->GetMode() == MutaborDevicePause ) {
            //                  In->Mode = MutaborDevicePlay;
            In->Play();
            //                  InDeviceAction(nr, In->Mode);
          }
        
        repaint_route();

        SetStatus(SG_PLAY);
}

void MutFrame::CmInDevStop ( wxCommandEvent & WXUNUSEDevent )

Definiert in Zeile 1654 der Datei MutFrame.cpp.

Benutzt LogicOn, MutFrame::repaint_route(), MutFrame::SetStatus() und MutFrame::StopInDev().

{
        StopInDev();
        repaint_route();
        SetStatus(1-LogicOn);
}

void MutLogicWnd::CmMutTag ( wxCommandEvent & event )

Definiert in Zeile 564 der Datei MutLogicWnd.cpp.

Benutzt MutTag::GetIsLogic(), MutTag::GetKey(), Tag() und MutLogicWnd::UpDate().

{
        MutTag *Tag = (MutTag*)event.GetEventObject();
        UpDate(Tag->GetKey(), Tag->GetIsLogic());
}

void MutFrame::CmPanic ( wxCommandEvent & WXUNUSEDevent )

Definiert in Zeile 1104 der Datei MutFrame.cpp.

Benutzt LogicOn und Panic().

{
        if ( LogicOn )
                Panic();
}

void MutApp::CmQuit ( wxCommandEvent & event )

Exit the program.

Definiert in Zeile 949 der Datei MutApp.cpp.

Benutzt _(), DEBUGLOG, MutApp::document_manager, muT, name und MutApp::quitting.

{
        DEBUGLOG (other, _T(""));

        SetExitOnFrameDelete(true);
        //              Exit();

        if (quitting) return;

        quitting = true;

        event.Skip(false);


        wxWindow * window;

        SetTopWindow(NULL);

        //      if (frames.empty()) {
        if ((window = GetTopWindow()) == NULL) {
                DEBUGLOG (other, _T("No Frames."));
                quitting = false;
                ExitMainLoop();
                return;
        }

        // first check whether docmanager allows quitting
        if (!document_manager.Clear(false))
        {
                quitting = false;
                return;
        }


        DEBUGLOG (other, _T("Starting Loop"));

        while (Pending())
                Dispatch();

        DEBUGLOG (other, _T("Dispatched all events"));

        wxIdleMode imode = wxIdleEvent::GetMode();
        wxIdleEvent::SetMode(wxIDLE_PROCESS_ALL);

        while ((window = GetTopWindow())) {
                DEBUGLOG (other, _("Closing window of class %s"), 
                          muT(typeid(*(window)).name()).c_str());

                if (!window->Close()) {
                        wxIdleEvent::SetMode(imode);
                        quitting = false;
                        return;
                }

                DEBUGLOG (other, _T("Closed window"));

                // empty queue and process idle event to delete the frame

                while (Pending())
                        Dispatch();

                //   wxIdleEvent idle;
                //ProcessEvent(idle);
                //while(Pending())
                //  Dispatch();
                DeletePendingObjects();

                DEBUGLOG (other, _T("Dispatched all events"));
        }


        DEBUGLOG (other, _T("finished loop"));
}

void MutApp::CmRoutes ( wxCommandEvent & event )

Open a new route editor.

Definiert in Zeile 862 der Datei MutApp.cpp.

Benutzt MutFrame::CmRoutes(), MutApp::CreateMainFrame(), MutApp::MustOpenFrame(), MutApp::RouteMenu und WK_ROUTE.

{

        wxWindow * topwindow=GetTopWindow();

#ifdef DEBUG
        std::cerr << "MutApp::CmRoutes: window "
        << wxWindow::FindWindowById(WK_ROUTE)
        << " casted "
        << dynamic_cast <MutFrame *>(wxWindow::FindWindowById(WK_ROUTE))
        << std::endl;
#endif

        MutFrame * frame = dynamic_cast<MutFrame*>(wxWindow::FindWindowById(WK_ROUTE));

        if (!frame) {
                frame = dynamic_cast<MutFrame*>(GetTopWindow());

                if (MustOpenFrame(frame))
                        frame = CreateMainFrame(RouteMenu);
        }

        frame->CmRoutes(event);

        frame->Show(true);
        event.Skip(false);
}

void MutFrame::CmRoutes ( wxCommandEvent & event )

Definiert in Zeile 1130 der Datei MutFrame.cpp.

Benutzt _(), MutFrame::auimanager, MutFrame::client, DEBUGLOG, ICON, LogicOn, MutFrame::UpdateBoxMenu() und WK_ROUTE.

Wird benutzt von MutApp::CmRoutes() und IMPLEMENT_APP().

{
        if ( GetId()== WK_ROUTE ) {
                DEBUGLOG (other, _T("setting Focus"));
                auimanager.Update();
                Raise();
                return;
        }

        if (client) {
                event.Skip(true);
                return;
        }

//      MutFrame *subframe = new MutFrame((wxFrame *) NULL,WK_ROUTE, wxString().Format(_("%s -- Routes"),_(PACKAGE_NAME)),
//              wxDefaultPosition,wxDefaultSize,wxDEFAULT_FRAME_STYLE | wxHSCROLL | wxVSCROLL);
//      subframe->SetIcon(ICON(route));

        SetId(WK_ROUTE);

        int width, height;

        GetClientSize(&width, &height);

        client = new MutRouteWnd(this, wxPoint(0, 0), wxSize(width, height));

        auimanager.AddPane(client,wxAuiPaneInfo().Caption(_("Routes")).CenterPane().PaneBorder(false));

        auimanager.Update();

        SetIcon(ICON(route));

        if (LogicOn) UpdateBoxMenu();
        
        SetSize(wxDefaultSize);

//      subframe->Show(true);

}

void MutFrame::CmSelectBox ( )

Definiert in Zeile 1437 der Datei MutFrame.cpp.

{
        /*wx  TPopupMenu *Menu = new TPopupMenu();
          Menu->AppendMenu(0, -1, "Select a box");
          Menu->AppendMenu(MF_SEPARATOR , -1, "");
          for (int box = 0; box < MAX_BOX; box++)
            if ( BoxUsed[box] )
            {
              char s[80];
              sprintf(s, "Box %d", box);
              Menu->AppendMenu((box == curBox) ? MF_CHECKED : 0, 10000+box, strdup(s));
            }
          TPoint p(200, 180);
          GetMainWindow()->ClientToScreen(p);
          Menu->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON,
            p, 0, *GetMainWindow(), 0);
          delete Menu;*/
}

void MutFrame::CmSetTitle ( wxCommandEvent & event )

Definiert in Zeile 1765 der Datei MutFrame.cpp.

Benutzt _() und APPNAME.

{
        SetTitle(wxString::Format(_("%s -- %s"), APPNAME, event.GetString().c_str()));
}

void MutFrame::CmStop ( wxCommandEvent & WXUNUSEDevent )

Definiert in Zeile 1099 der Datei MutFrame.cpp.

Benutzt MutFrame::DoStop().

{
        DoStop();
}

void MutLogicWnd::CmTaste ( )

Definiert in Zeile 444 der Datei MutLogicWnd.cpp.

Benutzt CM_MUTTAG, IsLogicKey(), pubTaste und MutLogicWnd::UpDate().

Wird benutzt von MutLogicWnd::OnChar().

{
        int key = pubTaste;
        /*      if ( key == WXK_TAB )
                {
                   HWND Handle = GetWindowPtr(GetFocus())->GetNextWindow(GW_HWNDNEXT);
                   if ( Handle )
                            GetWindowPtr(Handle)->SetFocus();
                   else
                            GetFirstChild()->SetFocus();
              SetFocusPos();
                   CorrectScroller();
          }
          else if ( key == VK_UP )
                   MoveFocus(0, -1);
          else if ( key == VK_DOWN )
                   MoveFocus(0, +1);
          else if ( key == VK_LEFT )
                   MoveFocus(-1, 0);
          else if ( key == VK_RIGHT )
                   MoveFocus(+1, 0);
          else if ( key == VK_F12 )
            MessageBox("This code was nearly completely written by R.K.", "Besides...", MB_OK | MB_ICONASTERISK);
          else*/

        if ( key == WXK_SPACE ) {
                /*              TWindow *Win = FirstThat(HasPosition, FocusPos);
                if ( Win ) Win->SetFocus();
                CorrectScroller();
                SetFocusPos();*/
                wxWindow *w = wxWindow::FindFocus();

                if ( w && w->GetId() == CM_MUTTAG )
                        UpDate(((MutTag*)w)->GetKey(), ((MutTag*)w)->GetIsLogic());
        } else {
                // Buchstabentaste
                // Umwandeln in Groﬂbuchstaben

                if ( 'a' <= key && key <= 'z' ) key += 'A' - 'a';

                // ermiteln, ob Logik
                char isLogic = IsLogicKey((char)key);

                if ( isLogic == 2 ) return;

                // Update aufrufen
                UpDate(key, isLogic);
        }
}

void MutFrame::CmToggleAct ( wxCommandEvent & WXUNUSEDevent )

Definiert in Zeile 1355 der Datei MutFrame.cpp.

Benutzt MutFrame::ToggleTextBox() und WK_ACT.

{
        ToggleTextBox(WK_ACT);
}

void MutFrame::CmToggleCAW ( wxCommandEvent & WXUNUSEDevent )

Definiert in Zeile 1386 der Datei MutFrame.cpp.

Benutzt MutFrame::auimanager, CAW, curBox, GenerateACTString(), GenerateCAWString(), Get(), LogicOn, MutFrame::TextBoxOpen(), WinAttr::Win, WinAttrs und WK_ACT.

{
        CAW = !CAW;

        if ( !LogicOn )
                return;

        // ActWin f¸r curBox updaten
        WinAttr *WinAttr = Get(WK_ACT, curBox);

        if ( WinAttr && WinAttr->Win )
                ((MutTextBox*)WinAttr->Win)->NewText(CAW ? GenerateCAWString() : GenerateACTString(curBox), 1);

        // andere Action-Fenster schlieﬂen bzw. ˆffnen
        if ( CAW ) {
                for (size_t i = 0; i < WinAttrs[WK_ACT].Count(); i++)
                        if ( WinAttrs[WK_ACT][i].Box != curBox && WinAttrs[WK_ACT][i].Win ) {
                                WinAttrs[WK_ACT][i].Wanted = 2; // um Wanted zu erhalten
                                auimanager.DetachPane(WinAttrs[WK_ACT][i].Win);
                        }
        } else
                for (size_t i = 0; i < WinAttrs[WK_ACT].Count(); i++)
                        if ( WinAttrs[WK_ACT][i].Box != curBox && WinAttrs[WK_ACT][i].Wanted )
                                TextBoxOpen(WK_ACT, WinAttrs[WK_ACT][i].Box);
}

void MutFrame::CmToggleKey ( wxCommandEvent & WXUNUSEDevent )

Definiert in Zeile 1345 der Datei MutFrame.cpp.

Benutzt MutFrame::ToggleTextBox() und WK_KEY.

{
        ToggleTextBox(WK_KEY);
}

void MutFrame::CmToggleOWM ( wxCommandEvent & WXUNUSEDevent )

Definiert in Zeile 1360 der Datei MutFrame.cpp.

Benutzt MutFrame::auimanager, curBox, LogicOn, MutFrame::LogicWinOpen(), OWM, MutFrame::TextBoxOpen(), WinAttrs, WK_KEY und WK_LOGIC.

{
        OWM = !OWM;

        if ( !LogicOn )
                return;

        if ( OWM ) {
                for (WinKind kind = WK_KEY; kind <= WK_LOGIC; kind++)
                        for (size_t i = 0; i < WinAttrs[kind].Count(); i++)
                                if ( WinAttrs[kind][i].Box != curBox && WinAttrs[kind][i].Win ) {
                                        WinAttrs[kind][i].Wanted = 2; // um Wanted zu erhalten
                                        auimanager.DetachPane(WinAttrs[kind][i].Win);
                                }
        } else
                for (WinKind kind = WK_KEY; kind <= WK_LOGIC; kind++)
                        for (size_t i = 0; i < WinAttrs[kind].Count(); i++)
                                if ( WinAttrs[kind][i].Box != curBox && WinAttrs[kind][i].Wanted )
                                {
                                        if ( kind == WK_LOGIC )
                                                LogicWinOpen(WinAttrs[kind][i].Box);
                                        else
                                                TextBoxOpen(kind, WinAttrs[kind][i].Box);
                                }
}

void MutFrame::CmToggleTS ( wxCommandEvent & WXUNUSEDevent )

Definiert in Zeile 1350 der Datei MutFrame.cpp.

Benutzt MutFrame::ToggleTextBox() und WK_TS.

{
        ToggleTextBox(WK_TS);
}

void MutLogicWnd::CorrectScroller ( )

Definiert in Zeile 570 der Datei MutLogicWnd.cpp.

Benutzt CM_MUTTAG, MUTTAGX und MUTTAGY.

Wird benutzt von MutLogicWnd::DoLayout().

{
        wxWindow *Win = wxWindow::FindFocus();

        if ( !Win || Win->GetId() != CM_MUTTAG )
                return;

        int xView, yView;

        GetViewStart(&xView, &yView);

        xView *=10;

        yView *=10;

        int xw, yw;

        Win->GetPosition(&xw, &yw);

        xw += xView;

        yw += yView;

        int w, h;

        GetClientSize(&w, &h);

        int dx = xView, dy = yView;

        // rechte untere Ecke im Bild ???
        if ( xw + MUTTAGX > xView+w ) dx = xw + MUTTAGX - w;

        if ( yw + MUTTAGY > yView+h ) dy = yw + MUTTAGY - h;

        // linke obere Ecke im Bild ??? (dominierend)
        if ( xw < xView ) dx = xw;

        if ( yw < yView ) dy = yw;

        Scroll(dx / 10, dy / 10);
}

bool MutPanel::Create	(	wxWindow *	parent,
		wxWindowID	winid = `wxID_ANY`,
		const wxPoint &	pos = `wxDefaultPosition`,
		const wxSize &	size = `wxDefaultSize`,
		long	style = `0`,
		const wxValidator &	validator = `wxDefaultValidator`,
		const wxString &	name = `wxPanelNameStr`
	)

Definiert in Zeile 127 der Datei Panel.cpp.

Wird benutzt von MutPanel::MutPanel().

{
        if (!wxControl::Create( parent, winid, pos, size, style, validator, name))
                return false;
        
        // so we don't have too much problems with background style settings.
        SetBackgroundStyle(wxBG_STYLE_SYSTEM);
            
        // so that non-solid background renders correctly under GTK+:
        SetThemeEnabled(true);

#if defined(__WXWINCE__) && (defined(__POCKETPC__) || defined(__SMARTPHONE__))
        // Required to get solid control backgrounds under WinCE
        SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
#endif

        return true;
}

void MutChild::deleteFromWinAttrs ( )

Definiert in Zeile 146 der Datei MutChild.cpp.

Benutzt _(), DEBUGLOG, MutTextBox::winAttr, WinAttrs, MutTextBox::winKind, WK_KEY und WK_NULL.

Wird benutzt von MutChild::OnAuiClose() und MutChild::~MutChild().

{
        DEBUGLOG (other, _T("winKind: %d"),winKind);
        wxASSERT(WK_KEY <= winKind &&winKind < WK_NULL);
        int i = WinAttrs[winKind].Index(*winAttr);
        wxASSERT(WK_KEY <= winKind &&i != wxNOT_FOUND);

        if (i == wxNOT_FOUND) {
                wxLogWarning(_("Subwindow is not in the list anymore. Please report this bug! %s in %s : %d"),__WXFUNCTION__,_T(__FILE__),__LINE__);
                return;
        }

        WinAttrs[winKind][i].Win = NULL;

        WinAttrs[winKind].RemoveAt(i,1);
        //    delete winAttr;
}

wxRect MutFrame::DetermineFrameSize ( )

Definiert in Zeile 1878 der Datei MutFrame.cpp.

Benutzt DEBUGLOG.

Wird benutzt von MutFrame::MutFrame().

{
        DEBUGLOG (other, _T(""));

        wxSize scr = wxGetDisplaySize();

        // determine default frame position/size
        wxRect normal;
        wxPoint currpos = GetPosition();

        if (scr.x <= 800) {
                normal.x = 40 / 2;
                normal.width = scr.x - 40;
        } else {
                normal.x = currpos.x;
                normal.width = 800;                     
        }

        if (scr.y <= 600) {
                normal.y = 80 / 2;
                normal.height = scr.y - 80;
        } else {
                normal.y = currpos.y;
                normal.height = 600;
        }

        return normal;
}

void MutLogicWnd::doClose ( wxEvent & event )

Definiert in Zeile 404 der Datei MutLogicWnd.cpp.

Benutzt CM_STOP, DEBUGLOG, DEBUGLOGBASE, NumberOfOpen() und WK_LOGIC.

Wird benutzt von MutLogicWnd::OnAuiClose() und MutLogicWnd::OnClose().

{
        DEBUGLOG (other, _T(""));
        wxWindow * parent;
        bool stop;
        wxCommandEvent event1(wxEVT_COMMAND_MENU_SELECTED, CM_STOP);

        if ( (stop = (NumberOfOpen(WK_LOGIC) <= 1) ) ) {
                parent = GetParent();

                while (!(dynamic_cast<MutFrame *>(parent))) {
                        DEBUGLOG (other, _T("Searching for MutFrame: %p..."),parent);
                        parent = parent->GetParent();
                }

                //GetApplication()->GetMainWindow()->PostMessage(WM_COMMAND, CM_STOP);
        }

        //    delete winAttr;
        event.Skip(false);

        Destroy();

        DEBUGLOGBASE(other,"MutLogicWnd",_T("Destroyed Window"));

        if (stop) wxPostEvent(parent,event1);

        DEBUGLOGBASE(other,"MutLogicWnd",_T("Destroyed Window"));
}

void MutLogicWnd::DoLayout ( ) [private]

Definiert in Zeile 504 der Datei MutLogicWnd.cpp.

Benutzt CM_MUTTAG, MutLogicWnd::ColorBar1, MutLogicWnd::ColorBar2, MutLogicWnd::CorrectScroller(), max, MUTTAGX, MUTTAGY und MutLogicWnd::nTags.

Wird benutzt von MutLogicWnd::OnSize() und MutLogicWnd::UpDate().

{
        wxSize R = GetClientSize();
        int nx = (R.GetWidth()-4) / MUTTAGX, ny = (R.GetHeight()-4)/ MUTTAGY;
        bool quer = R.GetWidth() > R.GetHeight();

        if ( nx * ny < nTags ) // Scroller notwendig
        {

                if  ( ny < 1) ny = 1;

                if ( quer ) nx = (nTags + ny -1) / ny;
        }
        std::cout << nTags << nx << std::endl;

        if  ( nx < 1 ) nx = 1;

        ny = (nTags + nx -1) / nx;

        int x = 4, y = 4, xi = 0;

        std::cout << nx << MUTTAGX << ny << MUTTAGY << std::endl;

        SetVirtualSize(nx*MUTTAGX+8, ny*MUTTAGY+8);

        int xv, yv;

        GetViewStart(&xv, &yv);

        for (wxWindowList::iterator i = GetChildren().begin(); i!=GetChildren().end(); i++) {
                wxWindow * Win= *i;
                if ( Win->GetId() == CM_MUTTAG ) {
                        //                      Win->Move(x - Scroller->XPos*Scroller->XUnit, y - Scroller->YPos*Scroller->YUnit, MUTTAGX, MUTTAGY, true);
                        Win->Move(x-xv*10, y-yv*10);
                        x += MUTTAGX;
                        xi++;

                        if ( xi == nx ) {
                                x = 4;
                                xi = 0;
                                y += MUTTAGY;
                        }
                }
        }

        if ( xi )
                y += MUTTAGY;

        // Farbbalken
        if ( ColorBar1 )
                ColorBar1->SetSize(-xv*10, -yv*10, max(nx*MUTTAGX+8, R.GetWidth()), 2);

        if ( ColorBar2 )
                ColorBar2->SetSize(-xv*10, -yv*10, 2, max(ny*MUTTAGY+8, R.GetHeight()));

        CorrectScroller();
};

void DontWant	(	WinKind	kind,
		int	box
	)

Definiert in Zeile 219 der Datei MutChild.cpp.

Benutzt Get(), WinAttr::Wanted, WK_KEY und WK_NULL.

Wird benutzt von MutFrame::CmDoActivate().

{
        wxASSERT(WK_KEY <= kind && kind < WK_NULL);

        WinAttr *Help;

        if ( (Help = Get(kind, box)) )
                Help->Wanted = 0;
}

void MutFrame::DoStop ( )

Definiert in Zeile 1067 der Datei MutFrame.cpp.

Benutzt AktionTraceReset(), MutFrame::ClearMenuItem(), MutFrame::CloseAll(), CM_SELECTBOX, DEBUGLOG, LogicOn, MutFrame::repaint_route(), MutFrame::SetStatus(), SG_NOTHING, Stop(), MutFrame::StopInDev(), WK_KEY und WK_LOGIC.

Wird benutzt von MutFrame::CmStop() und MutFrame::OnClose().

{
        if ( LogicOn ) {
                LogicOn = false;
                StopInDev();
                Stop();

                // Ampel umschalten
                /*              ControlBar->Remove(*ButtonStop);
                ControlBar->Insert(*ButtonActivate, TGadgetWindow::Before, ButtonPanic);
                ControlBar->LayoutSession();*/
                // Statusleiste
                SetStatus(SG_NOTHING);
                //              StatusBar->SetText("");
                // Titel
                //    SetTitle(APPNAME);
                // alle Fenser schlieﬂen
                wxMenuItem * boxSelector = ClearMenuItem(CM_SELECTBOX);
                wxASSERT(boxSelector->IsSubMenu());

                for (WinKind kind = WK_KEY; kind <= WK_LOGIC; kind++) {
                        DEBUGLOG (other, _T("Closing kind %d"),kind);
                        theFrame->CloseAll(kind);
                }

                AktionTraceReset();

                repaint_route();
                theFrame = NULL;
        }
}

RouteRemoveButton::RemoveButtonPressed END_EVENT_TABLE ( )

misc

Definiert in Zeile 759 der Datei MutApp.cpp.

{
        MutFrame* frame = new MutFrame((wxFrame *)NULL, wxID_ANY, _T("Mutabor"),
                                       wxDefaultPosition, wxDefaultSize, //wxSize(500, 400),
                                       wxDEFAULT_FRAME_STYLE | wxHSCROLL | wxVSCROLL);
        return InitMainFrame(type,frame);
}

void MutFrame::EventPassOn ( wxCommandEvent & event )

passes an event to the MDI client window.

Veraltet:: This function was formerly used to pass one event to the client MDI window.

Parameter:

event Event to be passed

Definiert in Zeile 620 der Datei MutFrame.cpp.

Benutzt MutFrame::auimanager.

{
        if ( event.GetEventObject() == NULL )
                // als Flag zur Sicherheit vor Endlosschleifen
                return;

        event.SetEventObject(NULL);

        /*      wxAUIPaneInfoArray &info = auimanager.GetAllPanes();

                if (!info.empty()) {
                        wxAUIPaneInfoArray::iterator it = info.first();

                }
        */
        std::cout << "Skippen? " << event.GetSkipped() <<
        " Propagate? " << event.ShouldPropagate() << std::endl;

        //        if (!GetClientWindow()->ProcessEvent(event)) {
        //      std::cout << "Event ignoriert von:" << GetClientWindow()->GetName().fn_str() << std::endl;
        //

        wxWindow * frame = auimanager.GetManagedWindow();

        if (frame) {
                wxPostEvent(frame,event);
                std::cout << "Event " << event.ShouldPropagate() << " war da:"
                << (frame->GetName().fn_str()) << std::endl;
        }

        //      }text.mb_str(*wxConvFileName)
        std::cout << frame << std::endl;

        event.Skip();

}

MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::OnMRUFile MutApp::CmRouteLoad MutApp::CmRouteSaveAs EVT_MENU	(	CM_HELP	,
		MutApp::CmHelp
	)

MutEditFile::CmCompile MutEditFile::CmCompAct EVT_MENU	(	CM_GETLINE	,
		MutEditFile::CmGetLine
	)

MutEditFile::CmCompile EVT_MENU	(	CM_COMPACT	,
		MutEditFile::CmCompAct
	)

MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD EVT_MENU	(	wxID_REDO	,
		MutApp::PassEventToDocManagerCMD
	)

MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::OnMRUFile MutApp::CmRouteLoad MutApp::CmRouteSaveAs MutApp::CmHelp EVT_MENU	(	CM_HELPREFERENCE	,
		MutApp::CmHelp
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear EVT_MENU	(	wxID_CUT	,
		MutEditFile::OnEditCut
	)

MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::OnMRUFile MutApp::CmRouteLoad MutApp::CmRouteSaveAs MutApp::CmHelp MutApp::CmHelp EVT_MENU	(	CM_HELPSEARCH	,
		MutApp::CmHelp
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy EVT_MENU	(	wxID_PASTE	,
		MutEditFile::OnEditPaste
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc EVT_MENU	(	CM_INDENTRED	,
		MutEditFile::OnEditIndentRed
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll EVT_MENU	(	CM_SELECTLINE	,
		MutEditFile::OnEditSelectLine
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo EVT_MENU	(	wxID_UNDO	,
		MutEditFile::OnEditUndo
	)

MutApp::CmSetup MutApp::PassEventToDocManagerCMD EVT_MENU	(	wxID_CLOSE_ALL	,
		MutApp::PassEventToDocManagerCMD
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind EVT_MENU	(	CM_FINDNEXT	,
		MutEditFile::OnFindNext
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch EVT_MENU	(	CM_GOTO	,
		MutEditFile::OnGoto
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang EVT_MENU	(	CM_DISPLAYEOL	,
		MutEditFile::OnDisplayEOL
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace EVT_MENU	(	CM_REPLACENEXT	,
		MutEditFile::OnReplaceNext
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang MutEditFile::OnIndentGuide EVT_MENU	(	CM_LINENUMBER	,
		MutEditFile::OnLineNumber
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang MutEditFile::OnIndentGuide MutEditFile::OnLongLineOn EVT_MENU	(	CM_WHITESPACE	,
		MutEditFile::OnWhiteSpace
	)

MutApp::CmSetup EVT_MENU	(	wxID_OPEN	,
		MutApp::PassEventToDocManagerCMD
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang MutEditFile::OnIndentGuide MutEditFile::OnLongLineOn MutEditFile::OnFoldToggle EVT_MENU	(	CM_OVERTYPE	,
		MutEditFile::OnSetOverType
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang MutEditFile::OnIndentGuide MutEditFile::OnLongLineOn MutEditFile::OnFoldToggle MutEditFile::OnSetReadOnly EVT_MENU	(	CM_WRAPMODEON	,
		MutEditFile::OnWrapmodeOn
	)

MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD EVT_MENU	(	wxID_NEW	,
		MutApp::PassEventToDocManagerCMD
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang MutEditFile::OnIndentGuide MutEditFile::OnLongLineOn MutEditFile::OnFoldToggle MutEditFile::OnSetReadOnly MutEditFile::OnUseCharset EVT_MENU	(	CM_CHARSETMAC	,
		MutEditFile::OnUseCharset
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang MutEditFile::OnIndentGuide MutEditFile::OnLongLineOn MutEditFile::OnFoldToggle MutEditFile::OnSetReadOnly MutEditFile::OnUseCharset MutEditFile::OnChangeCase EVT_MENU	(	CM_CHANGEUPPER	,
		MutEditFile::OnChangeCase
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang MutEditFile::OnIndentGuide MutEditFile::OnLongLineOn MutEditFile::OnFoldToggle MutEditFile::OnSetReadOnly MutEditFile::OnUseCharset MutEditFile::OnChangeCase MutEditFile::OnConvertEOL EVT_MENU	(	CM_CONVERTCRLF	,
		MutEditFile::OnConvertEOL
	)

MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD EVT_MENU	(	CM_EXECUTE	,
		MutApp::CmFileOpen
	)

MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD EVT_MENU	(	wxID_SAVEAS	,
		MutApp::PassEventToDocManagerCMD
	)

MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::OnMRUFile EVT_MENU	(	CM_ROUTES	,
		MutApp::CmRoutes
	)

MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::OnMRUFile MutApp::CmRouteLoad EVT_MENU	(	CM_ROUTESAVE	,
		MutApp::CmRouteSave
	)

MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::OnMRUFile MutApp::CmRouteLoad MutApp::CmRouteSaveAs MutApp::CmHelp MutApp::CmHelp MutApp::CmHelp EVT_MENU	(	CM_ABOUT	,
		MutApp::CmAbout
	)

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext EVT_SIZE ( MutEditFile::OnSize )

wxControl EVT_SIZE ( MutPanel::OnSize )

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch MutEditFile::OnHilightLang MutEditFile::OnIndentGuide MutEditFile::OnLongLineOn MutEditFile::OnFoldToggle MutEditFile::OnSetReadOnly MutEditFile::OnUseCharset MutEditFile::OnChangeCase MutEditFile::OnConvertEOL MutEditFile::OnConvertEOL EVT_STC_MARGINCLICK	(	wxID_ANY	,
		MutEditFile::OnMarginClick
	)

MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD EVT_UPDATE_UI	(	wxID_CLOSE	,
		MutApp::PassEventToDocManagerUPD
	)

MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD EVT_UPDATE_UI	(	wxID_REVERT	,
		MutApp::PassEventToDocManagerUPD
	)

MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD EVT_UPDATE_UI	(	wxID_SAVE	,
		MutApp::PassEventToDocManagerUPD
	)

MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD EVT_UPDATE_UI	(	wxID_UNDO	,
		MutApp::PassEventToDocManagerUPD
	)

WinAttr* Get	(	WinKind	kind,
		int	box
	)

Definiert in Zeile 182 der Datei MutChild.cpp.

Benutzt WinAttrs, WK_KEY und WK_NULL.

Wird benutzt von AppAbout::AppAbout(), MutApp::CmAbout(), MutFrame::CmToggleCAW(), DontWant(), MutApp::GetResourceName(), GetWinAttr(), IMPLEMENT_APP(), IsOpen(), IsWanted(), MutApp::OnExit(), MutFrame::RestoreState(), MutApp::RestoreState(), MutFrame::SaveState(), MutApp::SaveState(), MutFrame::ToggleTextBox() und MutFrame::UpdateUI().

{
        wxASSERT(WK_KEY <= kind && kind < WK_NULL);

        for (size_t i = 0; i < WinAttrs[kind].GetCount(); i++)
                if ( WinAttrs[kind][i].Box == box )
                        return &WinAttrs[kind][i];

        return 0;
}

wxAuiDockArt * MutFrame::GetDockArt ( )

Definiert in Zeile 1863 der Datei MutFrame.cpp.

Benutzt MutFrame::auimanager.

{
        std::cout << "MutFrame::GetDockArt()" << std::endl;
        return auimanager.GetArtProvider();
}

wxString MutApp::GetResourceName ( const wxString & file ) [static]

Get a possibly localized resource file name.

This function tries to find the file given by file in a localized version before returning it unlocalized if that is impossible.

For example, the file help.zip is searched for

first in /usr/share/mutabor/de_DE/help.zip,
otherwise in /usr/share/mutabor/de/help.zip.
If that fails /usr/share/mutabor/help.zip is returned unchecked.
Parameter:

file File name to be searched for.

Rückgabe:
localized file name.

Definiert in Zeile 1025 der Datei MutApp.cpp.

Benutzt DEBUGLOGTYPE, Get() und MutApp::m_locale.

{
        const wxLocale * m_locale = wxGetLocale();
        wxStandardPathsBase & sp = wxStandardPaths::Get();
        wxString localename = m_locale->GetCanonicalName();
        wxFileName rcname(sp.GetLocalizedResourcesDir(localename),file);
        DEBUGLOGTYPE(other,MutApp,_T("Trying do load resources...\n%s\n%s"),rcname.GetFullPath().c_str(),sp.GetResourcesDir().c_str());
        if (!rcname.IsFileReadable()) {
                rcname.SetPath(sp.GetLocalizedResourcesDir(localename.BeforeFirst(_T('_'))));
                DEBUGLOGTYPE(other,MutApp,_T("Trying %s"),rcname.GetFullPath().c_str());
                if (!rcname.IsFileReadable()) {
                        rcname.SetPath(sp.GetResourcesDir());
                        DEBUGLOGTYPE(other,MutApp,_T("Trying %s"),rcname.GetFullPath().c_str());
                }
        }
        localename = rcname.GetFullPath();
        return localename;
}

WinAttr* GetWinAttr	(	WinKind	kind,
		int	box
	)

Definiert in Zeile 165 der Datei MutChild.cpp.

Benutzt Get(), WinAttrs, WK_EDIT, WK_KEY und WK_NULL.

Wird benutzt von BEGIN_EVENT_TABLE() und MutFrame::TextBoxOpen().

{
        wxASSERT(WK_KEY <= kind &&kind < WK_NULL);
        WinAttr * attr;

        if ( kind != WK_EDIT ) {
                attr = Get (kind, box);

                if (attr) return attr;
        }

        attr = new WinAttr(true, box);

        WinAttrs[kind].Add(attr);
        return attr;
}

bool MutFrame::HasClient ( ) [inline]

retrun true if we have already a client

Definiert in Zeile 329 der Datei MutFrame.h.

Benutzt MutFrame::client.

Wird benutzt von MutApp::MustOpenFrame().

        {
                return (bool) client;
        }

IMPLEMENT_APP ( MutApp )

Definiert in Zeile 237 der Datei MutApp.cpp.

Benutzt _(), CM_ABOUT, CM_EXIT, CM_ROUTES, CM_SETUP, MutFrame::CmRoutes(), Get(), HelpController, MidiInit(), muT, MUT_LAST, name, PACKAGE_NAME und MutFrame::RestoreState().

        { wxMenu * menu = new wxMenu;

#define CLOSEMENU(name)                         \
        menuBar->Append(menu, name); }

#define MENUITEM(name, id, help)                \
        menu->Append(id, name, help)

#define MENUCHECKITEM(name, id, help)           \
        menu->AppendCheckItem(id, name, help)

#define MENUITEM_ADD(name, id, help, add)       \
        menu->Append(id, name, help, add)

#define MENUITEM_SEPARATOR                      \
        menu->AppendSeparator()

// Initialise this in OnInit, not statically
bool MutApp::OnInit()
{
        /* Short form for
           for (int i = MUT_FIRST; i < MUT_LAST; i++) 
           wxRegisterId(i);
        */
        wxRegisterId(MUT_LAST);

        SetAppName(_T(PACKAGE));
        SetClassName(_T(PACKAGE_NAME));
        
        wxStandardPaths& sp = (wxStandardPaths &) wxStandardPaths::Get();

#ifdef __LINUX__
        sp.SetInstallPrefix(_T(PREFIX));
#endif

        quitting = false;

        // initialize the languages
        m_locale.Init(wxLANGUAGE_DEFAULT);

        // TODO: Check this!
        // normally this wouldn't be necessary as the catalog files would be found
        // in the default locations, but under Windows then the program is not
        // installed the catalogs are in the parent directory (because the binary
        // is in a subdirectory of samples/internat) where we wouldn't find them by
        // default
        wxLocale::AddCatalogLookupPathPrefix(_T("."));
        wxLocale::AddCatalogLookupPathPrefix(wxT(".."));

        // Initialize the catalogs we'll be using
        m_locale.AddCatalog(wxT("mutabor"));
        m_locale.AddCatalog(wxT("wxstd"));
#ifdef __LINUX__
        {
                wxLogNull noLog;
                m_locale.AddCatalog(_T("fileutils"));
        }
#endif


#ifdef DEBUG
        std::cout << (muT(__FUNCTION__).ToUTF8()) << std::endl;
        std::cout << (muT(typeid(m_locale).name()).ToUTF8()) << std::endl;
        std::cout << "ConfigDir:        "

                  << (const char *)(sp.GetConfigDir().ToUTF8()) << std::endl
                  << "DataDir:          "
                  << (const char *)(sp.GetDataDir().ToUTF8()) << std::endl
                  << "DocumentsDir:     "
                  << (const char *)(sp.GetDocumentsDir().ToUTF8()) << std::endl
                  << "ExecutablePath:   "
                  << (const char *)(sp.GetExecutablePath().ToUTF8()) << std::endl

#if defined(__UNIX__) && !defined(__WXMAC__)
                  << "InstallPrefix:    " << (const char *)(sp.GetInstallPrefix().ToUTF8())
                  << std::endl
#endif
                  << "LocalDataDir:     " << (const char *)(sp.GetLocalDataDir().ToUTF8())
                  << std::endl
                  << "PluginsDir:       " << (const char *)(sp.GetPluginsDir().ToUTF8())
                  << std::endl
                  << "ResourcesDir:     " << (const char *)(sp.GetResourcesDir().ToUTF8())
                  << std::endl
                  << "TempDir:          " << (const char *)(sp.GetTempDir().ToUTF8())
                  << std::endl
                  << "UserConfigDir:    " << (const char *)(sp.GetUserConfigDir().ToUTF8())
                  << std::endl
                  << "UserDataDir:      " << (const char *)(sp.GetUserDataDir().ToUTF8())
                  << std::endl
                  << "UserLocalDataDir: " << (const char *)(sp.GetUserLocalDataDir().ToUTF8())
                  << std::endl;

        std::cout
                << "LocalizedResourcesDir(Can): "
                << (const char *)(sp.GetLocalizedResourcesDir(m_locale.GetCanonicalName(),
                                                              sp.ResourceCat_None).ToUTF8())
                << std::endl
                << "LocalizedResourcesDir(Can,Messages): "
                << (const char *)(sp.GetLocalizedResourcesDir(m_locale.GetCanonicalName(),
                                                              sp.ResourceCat_Messages).ToUTF8())
                << std::endl
                << "LocalizedResourcesDir(): "
                << (const char *)(sp.GetLocalizedResourcesDir(m_locale.GetName(),
                                                              sp.ResourceCat_None).ToUTF8())
                << std::endl
                << "LocalizedResourcesDir(Messages): "
                << (const char *)(sp.GetLocalizedResourcesDir(m_locale.GetName(),
                                                              sp.ResourceCat_Messages).ToUTF8())
                << std::endl;

#endif

        
        // We are using .png files for some extra bitmaps.
        wxImageHandler * pnghandler = new wxPNGHandler;
        wxImage::AddHandler(pnghandler);
        wxImage::AddHandler(new wxGIFHandler);
        
        wxFileSystem::AddHandler(new wxZipFSHandler);

        wxXmlResource::Get()->InitAllHandlers();
        wxString resfilename = GetResourceName(_T("Mutabor.xrc"));
        wxXmlResource::Get()->Load(resfilename);

        wxHelpControllerHelpProvider* provider = new wxHelpControllerHelpProvider;
        wxHelpProvider::Set(provider);
        HelpController = new wxHtmlHelpController();
        provider->SetHelpController(HelpController);

        // we want to name the help files according to the lanuage.
        if (!HelpController->Initialize(GetResourceName(_("Help.zip"))))
                std::cerr << "Warning: could not initialize Help system: "
                          << (const char *)(wxString(_("Help.zip")).ToUTF8()) << std::endl;


        //  restrict to having <= 1 doc open at any time
        document_manager.SetMaxDocsOpen(5);
        //  establish a doc template for the doc,view pair
        new wxDocTemplate(&document_manager, 
                          _("Mutabor logic file"), 
                          wxT("*.mut"), 
                          wxT("") /*dir*/, 
                          wxT("mut"), 
                          wxT("mutabor_logic_document"), 
                          wxT("mutabor_logic_view"), 
                          CLASSINFO(mutaborGUI::MutDocument), 
                          CLASSINFO(mutaborGUI::MutView) );
#ifdef __WXMAC__
        wxFileName::MacRegisterDefaultTypeAndCreator( wxT("mut") , 'MUTA' , 'MUTA' ) ;
#endif

#if defined(__WXMAC__)
        // || defined(__WXCOCOA__)
        // Make a common menubar

        wxApp::SetExitOnFrameDelete(false);
        wxApp::s_macAboutMenuItemId = CM_ABOUT;
        wxApp::s_macPreferencesMenuItemId = CM_SETUP;
        wxApp::s_macExitMenuItemId = CM_EXIT;
        wxApp::s_macHelpMenuTitleName = _("&Help");
        wxMenuBar *menuBar = new wxMenuBar;
        MakeFileMenu(menuBar,ProgramMenu);
        MakeViewMenu(menuBar,ProgramMenu);
        MakeHelpMenu(menuBar);
        wxMenuBar::MacSetCommonMenuBar(menuBar);
        
#endif

        // This call parses the command line
        if (!wxApp::OnInit()) return false;

        MidiInit();
        RestoreState();
                
        if (!GetTopWindow()) {
                MutFrame * frame = CreateMainFrame(EditorMenu);
                frame->RestoreState();
                wxCommandEvent event(CM_ROUTES);
                frame->CmRoutes(event);
                frame->Show(true);
        }

        return true;
}

IMPLEMENT_DYNAMIC_CLASS	(	MutPanel	,
		wxControl
	)

bool MutToolBarBitmaps::Init ( ) [static]

Definiert in Zeile 58 der Datei MutBitmaps.cpp.

                             {
        if (initialized) return(true);
        initMutBitmap(New,
                    wxGetApp().GetResourceName (_T ("document-new.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(Open,
                    wxGetApp().GetResourceName (_T ("document-open.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(Save,
                    wxGetApp().GetResourceName (_T ("document-save.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(SaveAs,
                    wxGetApp().GetResourceName (_T ("document-save-as.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(Print,
                    wxGetApp().GetResourceName (_T ("document-print.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(LogicActivate,
                    wxGetApp().GetResourceName (_T ("ActivateMutabor.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(LogicStop,
                    wxGetApp().GetResourceName (_T ("StopMutabor.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(LogicPanic,
                    wxGetApp().GetResourceName (_T ("Panic.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(Copy,
                    wxGetApp().GetResourceName (_T ("edit-copy.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(Cut,
                    wxGetApp().GetResourceName (_T ("edit-cut.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(Paste,
                    wxGetApp().GetResourceName (_T ("edit-paste.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(Undo,
                    wxGetApp().GetResourceName (_T ("edit-undo.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(Redo,
                    wxGetApp().GetResourceName (_T ("edit-redo.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(RouteLoad,
                    wxGetApp().GetResourceName (_T ("RouteLoad.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(RouteSave,
                    wxGetApp().GetResourceName (_T ("RouteSave.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(IndevsPlay,
                    wxGetApp().GetResourceName (_T ("InDevPlay.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(IndevsStop,
                    wxGetApp().GetResourceName (_T ("InDevStop.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(IndevsPause,
                    wxGetApp().GetResourceName (_T ("InDevPause.png")),
                    wxBITMAP_TYPE_PNG);
        initMutBitmap(About,
                    wxGetApp().GetResourceName (_T ("help-browser.png")),
                    wxBITMAP_TYPE_PNG);
        initialized = true;
        return true;    
}

wxControl wxControl void MutPanel::Init ( ) [protected]

Definiert in Zeile 122 der Datei Panel.cpp.

Wird benutzt von MutPanel::MutPanel().

{
    m_container.SetContainerWindow(this);
}

void MutPanel::InitDialog ( ) [virtual]

Definiert in Zeile 156 der Datei Panel.cpp.

{
        wxInitDialogEvent event(GetId());
        event.SetEventObject(this);
        GetEventHandler()->ProcessEvent(event);
}

MutFrame * MutApp::InitMainFrame	(	MenuType	type,
		MutFrame *	frame
	)

Initialize a main frame.

This function initialises a freshly created Top Level Frame.

Parameter:

frame frame that will be created

Definiert in Zeile 771 der Datei MutApp.cpp.

Benutzt MutApp::MakeEditMenu(), MutApp::MakeFileMenu(), MutApp::MakeHelpMenu(), MutApp::MakeLogicMenu(), MutApp::MakeRoutesMenu(), MutApp::MakeSequencerMenu(), MutApp::MakeViewMenu() und MutFrame::SetFileMenu().

{
#ifdef __WXMSW__
        frame->SetIcon(wxIcon(_T("mutabor_icn")));
#else
        frame->SetIcon(wxIcon( mutabor_xpm ));
#endif

        // Make a menubar

        wxMenuBar *menuBar = new wxMenuBar;
        frame->SetFileMenu(MakeFileMenu(menuBar, type));
        MakeEditMenu(menuBar, type);
        MakeLogicMenu(menuBar);
        MakeRoutesMenu(menuBar);
        MakeViewMenu(menuBar, type);
        MakeSequencerMenu(menuBar);
        MakeHelpMenu(menuBar);

        // Associate the menu bar with the frame
        frame->SetMenuBar(menuBar);

#if wxUSE_STATUSBAR
        frame->CreateStatusBar();
#endif // wxUSE_STATUSBAR

        return frame;
}

static void initMutBitmap	(	wxBitmap &	bitmap,
		const wxString &	filename,
		const wxBitmapType	type
	)		`[inline, static]`

Definiert in Zeile 46 der Datei MutBitmaps.cpp.

Wird benutzt von MutToolBarBitmaps::Init().

{
        if (!bitmap.IsOk())
                if(!bitmap.LoadFile(filename,type))
                        bitmap = wxNullBitmap;
}

void MutTag::InitText ( wxDC & dc )

Definiert in Zeile 177 der Datei MutLogicWnd.cpp.

Benutzt MUTTAGX, MutTag::Text und MutTag::TPos.

{
        int i = Text.Length();
        wxCoord w, h;
        dc.GetTextExtent(Text, &w, &h);

        if ( w <= MUTTAGX-4 ) TPos = 0;

        while ( i >= 0 ) {
                if ( Text[i] == '_' ) {
                        Text[i] = '-';
                        if ( TPos == -1 ) {
                                dc.GetTextExtent(Text.Left(i+1), &w, &h);
                                if ( w <= MUTTAGX-4 ) TPos = i+1;
                        }
                }

                i--;
        }

        if ( TPos == -1 ) TPos = 0;

        dc.GetTextExtent(Text.Mid(TPos), &w, &h);

        if ( w > MUTTAGX-4 )
                Text.Last() = '.';

        dc.GetTextExtent(Text.Mid(TPos), &w, &h);

        int l = Text.Length();

        while ( w > MUTTAGX-4 ) {
                l--;
                Text.Truncate(l);
                Text.Last() = '.';
                dc.GetTextExtent(Text.Mid(TPos), &w, &h);
        }
}

bool IsOpen	(	WinKind	kind,
		int	box
	)

Definiert in Zeile 193 der Datei MutChild.cpp.

Benutzt Get(), WinAttr::Win, WK_KEY und WK_NULL.

Wird benutzt von MutFrame::ToggleTextBox().

{
        wxASSERT(WK_KEY <= kind && kind < WK_NULL);

        WinAttr *Help;

        if ( (Help = Get(kind, box)) )
                if ( Help->Win )
                        return true;

        return false;
}

bool IsWanted	(	WinKind	kind,
		int	box
	)

Definiert in Zeile 206 der Datei MutChild.cpp.

Benutzt Get(), WinAttr::Wanted, WK_KEY und WK_NULL.

{
        wxASSERT(WK_KEY <= kind && kind < WK_NULL);

        WinAttr *Help;

        if ( (Help = Get(kind, box)) )
                if ( Help->Wanted )
                        return true;

        return false;
}

void MutFrame::LogicWinOpen ( int box )

Definiert in Zeile 1172 der Datei MutFrame.cpp.

Benutzt _(), MutFrame::auimanager, MutFrame::client und DEBUGLOG.

Wird benutzt von MutFrame::CmToggleOWM() und MutFrame::UpdateBoxMenu().

{
//  TMDIChild* curChild = Client->GetActiveMDIChild();
        /*  TMDIMutChild *Win = new TMDIMutChild(WK_LOGIC, GeWinAttr(WK_LOGIC, box), *Client, "", new TMutWin(0, Module));
          Win->SetIcon(this, IDI_MUTABOR);
          Win->SetIconSm(this, IDI_MUTABOR);
          if (curChild && (curChild->GetWindowLong(GWL_STYLE) & WS_MAXIMIZE))
                  Win->Attr.Style |= WS_MAXIMIZE;
          Win->Create();*/
//      MutChild *subframe = NewFrame(WK_LOGIC, box, _("Logic"), ICON(mutabor));



        int width, height;
        GetClientSize(&width, &height);
        width /= 2;
        height /= 2;
        MutLogicWnd *client = new MutLogicWnd(this, box,
                                              wxPoint(0, 0),
                                              wxSize(width,height));
        wxString Name;
        Name.Printf(_("Logic -- Box %d"),box);
        DEBUGLOG (other, _T("Adding pane '%s' with caption '%s'"), Name.Format(_T("Logic%d"),box).c_str(),Name.c_str());
        auimanager.AddPane(client,
                           wxAuiPaneInfo().Name(Name.Format(_T("Logic%d"),box))
                           .Caption(Name)
                           .Bottom()
                           .Floatable(true)
                           .CloseButton(false)
                           .MaximizeButton(true)
                           .Float());
        client->SetFocus();
        auimanager.Update();
}

void MutApp::MakeEditMenu	(	wxMenuBar *	menuBar,
		MenuType	type
	)		`[private]`

Creates an edit menu.

This function creates the editor menu.

Parameter:

menuBar	Menu bar, where the file menu is to be appended
type	Flags indicating, which menus shall be created.

Definiert in Zeile 1115 der Datei MutApp.cpp.

Benutzt _(), CLOSEMENU, CM_BRACEMATCH, CM_CHANGECASE, CM_CHANGELOWER, CM_CHANGEUPPER, CM_CONVERTCR, CM_CONVERTCRLF, CM_CONVERTEOL, CM_CONVERTLF, CM_FINDNEXT, CM_GOTO, CM_INDENTINC, CM_INDENTRED, CM_READONLY, CM_REPLACE, CM_REPLACENEXT, CM_SELECTLINE, MutApp::EditorMenu und OPENMENU.

Wird benutzt von MutApp::InitMainFrame().

{
        if (type != EditorMenu) return;

        OPENMENU;
        menu->Append (wxID_UNDO, _("&Undo\tCtrl+Z"));
        menu->Append (wxID_REDO, _("&Redo\tCtrl+Shift+Z"));
        menu->AppendSeparator();
        menu->Append (wxID_CUT, _("Cu&t\tCtrl+X"));
        menu->Append (wxID_COPY, _("&Copy\tCtrl+C"));
        menu->Append (wxID_PASTE, _("&Paste\tCtrl+V"));
        menu->Append (wxID_CLEAR, _("&Delete\tDel"));
        menu->AppendSeparator();
        menu->Append (wxID_SELECTALL, _("&Select all\tCtrl+A"));
        menu->Append (CM_SELECTLINE, _("Select &line\tCtrl+L"));
        menu->AppendSeparator();
        menu->Append (wxID_FIND, _("&Find\tCtrl+F"));
        menu->Enable (wxID_FIND, false);
        menu->Append (CM_FINDNEXT, _("Find &next\tF3"));
        menu->Enable (CM_FINDNEXT, false);
        menu->Append (CM_REPLACE, _("&Replace\tCtrl+H"));
        menu->Enable (CM_REPLACE, false);
        menu->Append (CM_REPLACENEXT, _("Replace &again\tShift+F4"));
        menu->Enable (CM_REPLACENEXT, false);
        menu->AppendSeparator();
        menu->Append (CM_BRACEMATCH, _("&Match brace\tCtrl+M"));
        menu->Append (CM_GOTO, _("&Goto\tCtrl+G"));
        menu->Enable (CM_GOTO, false);
        menu->AppendSeparator();
        menu->Append (CM_INDENTINC, _("&Indent increase\tTab"));
        menu->Append (CM_INDENTRED, _("I&ndent reduce\tBksp"));

        // change case submenu
        wxMenu *menuChangeCase = new wxMenu;
        menuChangeCase->Append (CM_CHANGEUPPER, _("&Upper case"));
        menuChangeCase->Append (CM_CHANGELOWER, _("&Lower case"));

        // convert EOL submenu
        wxMenu *menuConvertEOL = new wxMenu;
        menuConvertEOL->Append (CM_CONVERTCR, _("CR (&Linux)"));
        menuConvertEOL->Append (CM_CONVERTCRLF, _("CR+LF (&Windows)"));
        menuConvertEOL->Append (CM_CONVERTLF, _("LF (&Macintosh)"));

        menu->AppendCheckItem (CM_READONLY, _("&Readonly mode"));
        menu->Append (CM_CHANGECASE, _("Change &case to ..."), menuChangeCase);
        menu->Append (CM_CONVERTEOL, _("Convert line &endings to ..."), 
                      menuConvertEOL);

        CLOSEMENU(_("&Edit"));
}

wxMenu * MutApp::MakeFileMenu	(	wxMenuBar *	menuBar,
		MenuType	type
	)		`[private]`

Creates a file menu.

This function creates the file menu.

Parameter:

menuBar	Menu bar, where the file menu is to be appended
type	Flags indicating, which menus shall be created.

Definiert in Zeile 1044 der Datei MutApp.cpp.

Benutzt _(), CLOSEMENU, CM_EXECUTE, CM_FILENEW, CM_FILEOPEN, CM_FILESAVE, CM_FILESAVEAS, CM_PROPERTIES, DEBUGLOG, MutApp::document_manager, MutApp::EditorMenu, getContextLocal(), MENUITEM, MENUITEM_SEPARATOR, OPENMENU und MutApp::RouteMenu.

Wird benutzt von MutApp::InitMainFrame().

{
        wxMenu * retval;
        OPENMENU;
        retval = menu;
        MENUITEM(_("&New\tCtrl+N"), CM_FILENEW,
                 _("Create a new logic file."));
        MENUITEM(_("&Open...\tCtrl+O"), CM_FILEOPEN,
                 _("Open a logic file in editor window"));

        if (type == EditorMenu || type == RouteMenu) {
                MENUITEM(_("&Save\tCtrl+S"), CM_FILESAVE,
                         _("Save the current file."));
                MENUITEM(_("Save &As...\tShift+Ctrl+S"), CM_FILESAVEAS,
                         _("Save the current file with a new file name"));
                menu->Append (wxID_CLOSE, 
                                  _("&Close\tCtrl+W"),
                                  _("Closes the currently active window"));
                menu->AppendSeparator();
        }

        MENUITEM_SEPARATOR;

        MENUITEM(_("&Execute\tCtrl+F9"), CM_EXECUTE,
                 _("Load a logic file an immediately activate it"));

#if (defined(__WXMAC__) || defined(__WXCOCOA__))
        if (type == EditorMenu)
#endif
        MENUITEM_SEPARATOR;

        if (type == EditorMenu) {
                menu->Append (CM_PROPERTIES,
                              _("Proper&ties ..\tCtrl+I"),
                              _("Get some information about the currently edited file"));
        } 
        MENUITEM(_("&Preferences"), CM_SETUP, _("Edit program settings"));


        if (type == EditorMenu) {
                menu->AppendSeparator();
                menu->Append (wxID_PRINT_SETUP,
                              _("Print Set&up ..."),
                              _("Configure the printer settings"));
                menu->Append (wxID_PREVIEW, 
                              _("Print Pre&view\tCtrl+Shift+P"),
                              _("Show document as it would be printed"));
                menu->Append (wxID_PRINT,
                              _("&Print ..\tCtrl+P"),
                              _("Print current document on a printer"));
        }



#if !(defined(__WXMAC__) || defined(__WXCOCOA__))
        MENUITEM_SEPARATOR;
#endif
        MENUITEM(_("E&xit"), CM_EXIT, _("Quit Mutabor"));
        DEBUGLOG(docview,_T("Adding file history menu"));
        document_manager.FileHistoryUseMenu(menu);
        document_manager.GetFileHistory()->AddFilesToMenu(menu);

#if !(defined(__WXMAC__) || defined(__WXCOCOA__))
        CLOSEMENU(_("&File"));
#else
        CLOSEMENU(getContextLocal(_("@MAC|&File")));
#endif
        return retval;

}

void MutApp::MakeHelpMenu ( wxMenuBar * menuBar ) [private]

Creates a mutabor help menu.

This function creates the help menu.

Parameter:

menuBar Menu bar, where the file menu is to be appended

Definiert in Zeile 1269 der Datei MutApp.cpp.

Benutzt _(), CLOSEMENU, cmCallExitId, MENUITEM, MENUITEM_SEPARATOR und OPENMENU.

Wird benutzt von MutApp::InitMainFrame().

{
        OPENMENU;
        MENUITEM(_("Online &Help\tF1"), CM_HELP,
                 _("Open the help Window"));
        MENUITEM(_("&Manual"), CM_HELPHANDBOOK,
                 _("Open the manual"));
        MENUITEM(_("Language &reference"), CM_HELPREFERENCE,
                 _("Open the Mutabor language reference"));
        MENUITEM_SEPARATOR;
        MENUITEM(_("&Index"), CM_HELPINDEX,
                 _("Open the help index"));
        MENUITEM(_("&Search"), CM_HELPSEARCH,
                 _("Search the help system for a specific keyword"));
        MENUITEM_SEPARATOR;
        MENUITEM(_("Help &on help"), CM_HELPONHELP,
                 _("Show Help about the help system"));

#if !(defined(__WXMAC__) || defined(__WXCOCOA__))
        MENUITEM_SEPARATOR;
#endif

        MENUITEM(_("&About"), CM_ABOUT,
                 _("Show information about the program"));
#ifdef DEBUG
        MENUITEM_SEPARATOR;
        MENUITEM(_("Stop"), cmCallExitId,
                 _("Stop the current program"));
#endif
        CLOSEMENU(_("&Help"));
}

void MutApp::MakeLogicMenu ( wxMenuBar * menuBar ) [private]

Creates a mutabor logic menu.

This function creates the logic menu.

Parameter:

menuBar Menu bar, where the file menu is to be appended

Definiert in Zeile 1167 der Datei MutApp.cpp.

Benutzt _(), CLOSEMENU, CM_ACTIVATE, CM_COMPILE, CM_PANIC, CM_STOP, MENUITEM, MENUITEM_SEPARATOR und OPENMENU.

Wird benutzt von MutApp::InitMainFrame().

{
        OPENMENU;
        MENUITEM(_("&Compile\tAlt+F9"), CM_COMPILE, _("Load the actual file into the Mutabor Kernel."));
        MENUITEM(_("&Activate\tF9"), CM_ACTIVATE, _("Activate the Mutabor Kernel."));
        MENUITEM(_("&Stop\tF8"), CM_STOP, _("Stop the Mutabor Kernel."));
        MENUITEM_SEPARATOR;
        MENUITEM(_("&Panic\tF12"), CM_PANIC, _("Send \"all notes off\" signal to on all MIDI Channels."));
        CLOSEMENU(_("&Logic"));
}

void MutApp::MakeRoutesMenu ( wxMenuBar * menuBar ) [private]

Creates a mutabor routes menu.

This function creates the roues menu.

Parameter:

menuBar Menu bar, where the file menu is to be appended

Definiert in Zeile 1178 der Datei MutApp.cpp.

Benutzt _(), CLOSEMENU, MENUITEM und OPENMENU.

Wird benutzt von MutApp::InitMainFrame().

{
        OPENMENU;
        MENUITEM(_("&Load routes"), CM_ROUTELOAD,
                 _("Load the current route configuration from a file"));
        MENUITEM(_("&Save routes"), CM_ROUTESAVE,
                 _("Save current route configuration to a file."));
        MENUITEM(_("Save routes &as"), CM_ROUTESAVEAS,
                 _("Save current route configuration to a file with a new name."));
        CLOSEMENU(_("&Routes"));
}

void MutApp::MakeSequencerMenu ( wxMenuBar * menuBar ) [private]

Creates a mutabor sequencer menu.

This function creates the sequencer menu.

Parameter:

menuBar Menu bar, where the file menu is to be appended

Definiert in Zeile 1256 der Datei MutApp.cpp.

Benutzt _(), CLOSEMENU, CM_INDEVPAUSE, CM_INDEVPLAY, CM_INDEVSTOP, MENUITEM und OPENMENU.

Wird benutzt von MutApp::InitMainFrame().

{
        OPENMENU;
        MENUITEM(_("&Play"), CM_INDEVPLAY,
                 _("Start playing the music from input file devices"));
        MENUITEM(_("St&op"), CM_INDEVSTOP,
                 _("Stop playing the music from input file devices"));
        MENUITEM(_("P&ause"), CM_INDEVPAUSE,
                 _("Pause plaing the music from input file devices"));
        CLOSEMENU(_("&Sequencer"));
}

void MutApp::MakeViewMenu	(	wxMenuBar *	menuBar,
		MenuType	type
	)		`[private]`

Creates a View menu.

This function creates the view menu.

Parameter:

menuBar	Menu bar, where the file menu is to be appended
type	Flags indicating, which menus shall be created.

Definiert in Zeile 1190 der Datei MutApp.cpp.

Benutzt _(), CLOSEMENU, CM_CHARSETANSI, CM_CHARSETMAC, CM_DISPLAYEOL, CM_FOLDTOGGLE, CM_HILIGHTFIRST, CM_HILIGHTLANG, CM_INDENTGUIDE, CM_LINENUMBER, CM_LONGLINEON, CM_OVERTYPE, CM_SELECTBOX, CM_TOGGLEACT, CM_TOGGLEKEY, CM_TOGGLETS, CM_USECHARSET, CM_WHITESPACE, CM_WRAPMODEON, MutApp::EditorMenu, mutaborGUI::g_LanguagePrefs, mutaborGUI::g_LanguagePrefsSize, MENUCHECKITEM, MENUITEM_SEPARATOR, name, OPENMENU und MutApp::ProgramMenu.

Wird benutzt von MutApp::InitMainFrame().

{
        

        OPENMENU;
        if (type == EditorMenu) {
                // hilight submenu
                wxMenu *menuHilight = new wxMenu;
                int Nr;
                for (Nr = 0; Nr < g_LanguagePrefsSize; Nr++) {
                        menuHilight->Append (CM_HILIGHTFIRST + Nr,
                                             g_LanguagePrefs [Nr].name);
                }

                // charset submenu
                wxMenu *menuCharset = new wxMenu;
                menuCharset->Append (CM_CHARSETANSI, _("&ANSI (Windows)"));
                menuCharset->Append (CM_CHARSETMAC, _("&MAC (Macintosh)"));

                menu->Append (CM_HILIGHTLANG, _("&Hilight language .."), menuHilight);
                menu->AppendSeparator();
                menu->AppendCheckItem (CM_FOLDTOGGLE, _("&Toggle current fold\tCtrl+T"));
                menu->AppendCheckItem (CM_OVERTYPE, _("&Overwrite mode\tIns"));
                menu->AppendCheckItem (CM_WRAPMODEON, _("&Wrap mode\tCtrl+U"));
                menu->AppendSeparator();
                menu->AppendCheckItem (CM_DISPLAYEOL, _("Show line &endings"));
                menu->AppendCheckItem (CM_INDENTGUIDE, _("Show &indent guides"));
                menu->AppendCheckItem (CM_LINENUMBER, _("Show line &numbers"));
                menu->AppendCheckItem (CM_LONGLINEON, _("Show &long line marker"));
                menu->AppendCheckItem (CM_WHITESPACE, _("Show white&space"));
                menu->AppendSeparator();
                menu->Append (CM_USECHARSET, _("Use &code page of .."), menuCharset);
                menu->AppendSeparator();
        }
        
        /*      MENUCHECKITEM(_("&Status bar"), IDW_STATUSBAR,
           _("Toggle status bar on/off"));
        MENUCHECKITEM(_("&Toolbar"), IDW_TOOLBAR,
           _("Toggle tool bar on/off"));
        MENUITEM_SEPARATOR;
        */
        MENUCHECKITEM(_("&Routes\tF11"), CM_ROUTES,
                      _("Open route configuration window"));

        if (type != ProgramMenu) {
                MENUITEM_SEPARATOR;
                MENUCHECKITEM(_("Current ke&ys\tF5"), CM_TOGGLEKEY,
                              _("Show current keys window"));
                MENUCHECKITEM(_("&Tone system\tF6"), CM_TOGGLETS,
                              _("Show tone system window"));
                MENUCHECKITEM(_("&Actions\tF7"), CM_TOGGLEACT,
                              _("Show current actions window"));
                /*        MENUITEM_SEPARATOR;
                MENUCHECKITEM(_("&One window mode"), CM_OWM,
                _("Toggle logic satus window: one each or one common"));
                MENUCHECKITEM(_("One &common action window"), CM_CAW,
                _("Toggle action window mode: one each or one common"));
                */
                MENUITEM_SEPARATOR;
                menu->Append(CM_SELECTBOX,_("Select &Box"), new wxMenu(),
                             _("Select current Box"));
        }

        CLOSEMENU(_("&View"));
}

MutFrame::MutFrame	(	MutDocument *	doc,
		MutView *	v,
		wxFrame *	frame,
		wxWindowID	id,
		const wxString &	title,
		const wxPoint &	pos = `wxDefaultPosition`,
		const wxSize &	size = `wxDefaultSize`,
		long	type = `wxDEFAULT_FRAME_STYLE`,
		const wxString &	name = `wxT("Mutabor frame")`
	)

Definiert in Zeile 504 der Datei MutFrame.cpp.

Benutzt _(), MutFrame::auimanager, MutFrame::client, MutFrame::DetermineFrameSize(), MutFrame::editmenu und MutFrame::filemenu.

                                        :
        wxDocChildFrame(doc,v,frame,id,title,pos,size,type,name),
        curStatusImg(0)
{

        SetSize (DetermineFrameSize ());
        client = NULL;
        editmenu = filemenu = NULL;

        auimanager.SetManagedWindow(this);


#if wxUSE_TOOLBAR
        wxToolBar * tb = new  wxToolBar(this,
                                        wxID_ANY,
                                        wxDefaultPosition,
                                        wxDefaultSize,
                                        wxTB_DOCKABLE);
        InitToolBar(tb);

        auimanager.AddPane(tb, wxAuiPaneInfo().
                           Name(_T("tb")).Caption(_("Toolbar")).
                           ToolbarPane().Top().
                           LeftDockable(false).RightDockable(false));
#endif // wxUSE_TOOLBAR


        // Accelerators
        /*    wxAcceleratorEntry entries[3];
            entries[0].Set(wxACCEL_CTRL, (int) 'N', MDI_NEW_WINDOW);
            entries[1].Set(wxACCEL_CTRL, (int) 'X', MDI_QUIT);
            entries[2].Set(wxACCEL_CTRL, (int) 'A', MDI_ABOUT);
            wxAcceleratorTable accel(3, entries);
            SetAcceleratorTable(accel);*/
}

wxSize MutTagSize	(	MUTTAGX	,
		MUTTAGY
	)

MutTextBox::MutTextBox	(	WinKind	k,
		WinAttr *	a,
		wxWindow *	parent = `NULL`,
		wxWindowID	id = `-1`,
		const wxPoint &	pos = `wxDefaultPosition`,
		const wxSize &	size = `wxDefaultSize`
	)

Definiert in Zeile 65 der Datei MutTextBox.cpp.

Benutzt MutTextBox::ColorBox und DEBUGLOG.

                                          :
                wxListBox(parent, id, pos, size, 1, ListInit),
                winKind(k),
                winAttr(a)
{
        DEBUGLOG (other, _T(""));
        /*  Attr.Style &= ~LBS_SORT;
          Attr.Style |= LBS_NOINTEGRALHEIGHT | WS_CLIPCHILDREN | WS_HSCROLL | WS_VSCROLL | LBS_NOSEL;
          ColorBar1 = new TControl(this, 0, "", 1, 1, 1000, 1);
          ColorBar2 = new TControl(this, 0, "", 1, 1, 1, 1000);*/
        ColorBox = -1;
}

void MutTextBox::NewText	(	char *	s,
		bool	newTitle = `false`
	)

Definiert in Zeile 96 der Datei MutTextBox.cpp.

Benutzt Clear(), DEBUGLOG, muT, MutTextBox::winKind, WK_ACT, WK_KEY und WK_NULL.

Wird benutzt von MutFrame::TextBoxOpen().

{
        wxASSERT(WK_KEY <= winKind && winKind < WK_NULL);
        DEBUGLOG (other, _T(""));
        // Text in Liste
        Clear();
        char s1[2000];
        int i = 0, j = 0;

        while ( s[i] ) {
                if ( s[i] == '\r' || s[i] == '\n' ) {
                        s1[j] = 0;

                        if ( j )
                                Append(wxString(muT(s1)));

                        j = 0;

                        i++;
                } else
                        s1[j++] = s[i++];
        }

        s1[j] = 0;

        if ( j )
                Append(wxString(muT(s1)));

        // Titel setzen
        if ( newTitle ) {

                std::cerr << "Not implemented: MutTextBox::NewText(...,newTitle=true);" << std::endl;
                /*
                  GetParent()->SetName(PARENT_KIND != WK_ACT || !CAW ? wxString::Format(_("%s - Box %d"), TextBoxTitle[PARENT_KIND].c_str(), Box()) : wxString(_("Actions - all boxes")));
                  int NewColorBox = UseColorBars ? Box() : -1;
                  if ( ColorBox != NewColorBox )
                  {
                    ColorBox = NewColorBox;
                */
                /*wx      ColorBar1->SetBkgndColor(BoxColor(ColorBox));
                      ColorBar2->SetBkgndColor(BoxColor(ColorBox));
                      ColorBar1->Invalidate();
                      ColorBar2->Invalidate();
                      ColorBar1->SendMessage(WM_PAINT);
                      ColorBar2->SendMessage(WM_PAINT);*/
//    }
        }

        // Scrollen, falls Aktion-Window
        if ( winKind == WK_ACT )
                SetSelection(GetCount()-1);

        // Farbbalken ggf. korrigieren
        /*  if ( GetTopIndex() == 0 && PARENT_KIND != WK_ACT )
          {
            ColorBar1->MoveWindow(1, 1, 1000, 1, true);
            ColorBar2->MoveWindow(1, 1, 1, 1000, true);
          }*/
}

void MutTextBox::NewText	(	wxString	s,
		bool	newTitle = `false`
	)

Definiert in Zeile 156 der Datei MutTextBox.cpp.

Benutzt Clear(), DEBUGLOG, MutTextBox::winKind, WK_ACT, WK_KEY und WK_NULL.

{
        DEBUGLOG (other, _T("s=%s; newTitle=%d; winKind=%d"),s.c_str(),newTitle,winKind);
        wxASSERT(WK_KEY <= winKind && winKind < WK_NULL);
        // Text in Liste
        Clear();



        wxStringTokenizer tokenizer(s,_T("\r\n"));

        while (tokenizer.HasMoreTokens())
                Append(tokenizer.GetNextToken());

        // Titel setzen
        if ( newTitle ) {
                std::cerr << "Not implemented: MutTextBox::NewText(...,newTitle=true);" << std::endl;

                /*    GetParent()->SetName(PARENT_KIND != WK_ACT || !CAW ? wxString::Format(_("%s - Box %d"), TextBoxTitle[PARENT_KIND].c_str(), Box()) : wxString(_("Actions - all boxes")));
                    int NewColorBox = UseColorBars ? Box() : -1;
                    if ( ColorBox != NewColorBox )
                    {
                      ColorBox = NewColorBox;
                          */
                /*wx      ColorBar1->SetBkgndColor(BoxColor(ColorBox));
                      ColorBar2->SetBkgndColor(BoxColor(ColorBox));
                      ColorBar1->Invalidate();
                      ColorBar2->Invalidate();
                      ColorBar1->SendMessage(WM_PAINT);
                      ColorBar2->SendMessage(WM_PAINT);*/
//    }
        }

        // Scrollen, falls Aktion-Window
        if ( winKind == WK_ACT )
                SetSelection(GetCount()-1);

        // Farbbalken ggf. korrigieren
        /*  if ( GetTopIndex() == 0 && PARENT_KIND != WK_ACT )
          {
            ColorBar1->MoveWindow(1, 1, 1000, 1, true);
            ColorBar2->MoveWindow(1, 1, 1, 1000, true);
          }*/
}

int NumberOfOpen ( WinKind kind )

Definiert in Zeile 229 der Datei MutChild.cpp.

Benutzt WinAttrs, WK_KEY und WK_NULL.

Wird benutzt von MutLogicWnd::doClose() und MutFrame::WindowSize().

{
        wxASSERT(WK_KEY <= kind && kind < WK_NULL);

        int n = 0;

        for (size_t i = 0; i < WinAttrs[kind].Count(); i++)
                if ( WinAttrs[kind][i].Win )
                        n++;

        return n;
}

void MutChild::OnActivate ( wxActivateEvent & event )

Definiert in Zeile 139 der Datei MutChild.cpp.

Benutzt WinAttr::Box, curBox, DEBUGLOG, MutTextBox::winAttr, MutTextBox::winKind, WK_KEY und WK_NULL.

{
        wxASSERT(WK_KEY <= winKind &&winKind < WK_NULL);
        DEBUGLOG (other, _T(""));
        curBox = winAttr->Box;
}

void MutTag::OnChar ( wxKeyEvent & event )

Definiert in Zeile 310 der Datei MutLogicWnd.cpp.

{
//  TButton::EvChar(key, repeatCount, flags);

        if ( ('A' < event.GetKeyCode() && event.GetKeyCode() <= 'z') || event.GetKeyCode() == WXK_TAB || event.GetKeyCode() == WXK_RETURN || event.GetKeyCode() == WXK_SPACE )
                wxPostEvent(GetParent(),event);
}

void MutLogicWnd::OnChar ( wxKeyEvent & event )

Definiert in Zeile 437 der Datei MutLogicWnd.cpp.

Benutzt MutLogicWnd::CmTaste() und pubTaste.

{
        pubTaste = event.GetKeyCode();
        CmTaste();
        event.Skip();
}

void MutFrame::OnClose ( wxCloseEvent & event )

Handles close event.

This function tries to determine, if we can close the current window.

Definiert in Zeile 657 der Datei MutFrame.cpp.

Benutzt _(), DEBUGLOG, MutFrame::DoStop() und MutFrame::SaveState().

{
        DEBUGLOG (other, _T("%x == %x"),this,theFrame);

        if (theFrame == this) {
                DEBUGLOG (other, _T("We are the active window."));

                if ( event.CanVeto() ) {
                        wxString msg;
                        msg.Printf(_("This logic is currently active. On closing it will be deactivated. Really close this window?"));

                        if ( wxMessageBox(msg, _("Please confirm closing."),
                                          wxICON_QUESTION | wxYES_NO) != wxYES ) {
                                event.Veto();
                                return;
                        }
                }

                DoStop();
        }


        SaveState();


        // wxDocChildFrame will veto if there is no View associated
        if (m_childView)
                wxDocChildFrame::OnCloseWindow(event);
        else 
                Destroy();
}

void MutTextBox::OnClose ( wxCloseEvent & event )

Erneute Implementation in MutChild.

Definiert in Zeile 85 der Datei MutTextBox.cpp.

Benutzt curBox, DEBUGLOG, TextBoxWanted, MutTextBox::winKind, WK_KEY und WK_NULL.

{
        wxASSERT(WK_KEY <= winKind && winKind < WK_NULL);
        DEBUGLOG (other, _T("winKind: %d"), winKind);
        //      if ( LogicOn )
        TextBoxWanted[curBox][winKind] = false;
        //              event.Skip(true);
        Destroy();
}

bool MutApp::OnCmdLineParsed ( wxCmdLineParser & parser )

Process command line arguments.

Definiert in Zeile 451 der Datei MutApp.cpp.

Benutzt DEBUGLOG.

                                                     {
        if (!wxApp::OnCmdLineParsed(parser)) return false;
#ifdef DEBUG
        debugFlags::ProcessCommandLine(parser);
#endif
        wxString str;
        int count = parser.GetParamCount();
        for (int i = 0; i<count;i++)
        {
                // we have a document to open
                str = parser.GetParam(i);
                printf("cmd line param: %ls\n", WXSTRINGCAST(str));
                // this will probably see if the file exists, and has the right extension

//              MutFrame * frame = CreateMainFrame(EditorMenu);
//              frame->OpenFile(str);

                document_manager.CreateDocument(str, wxDOC_SILENT);
        }

        DEBUGLOG (other, _T("Command line parsed."));
        return true;
}

void MutFrame::OnEraseBackground ( wxEraseEvent & event )

Definiert in Zeile 1857 der Datei MutFrame.cpp.

Benutzt MutFrame::client.

{
        if (client)
                event.Skip();
}

int MutApp::OnExit ( ) [virtual]

Callback for program quitting.

While quitting wxWidgets calls this virtual function. We use it to save the current setup.

Definiert in Zeile 1302 der Datei MutApp.cpp.

Benutzt AktionTraceReset(), Get(), HelpController, MidiUninit() und MutApp::SaveState().

{
        SaveState();
        AktionTraceReset();
        MidiUninit();
#if defined(__WXMAC__)
        wxMenuBar::MacSetCommonMenuBar(NULL);
#endif
        delete HelpController;
        wxXmlResource::Get()->ClearHandlers();
        return wxApp::OnExit();
}

void MutTag::OnFocus ( wxFocusEvent & event )

Definiert in Zeile 327 der Datei MutLogicWnd.cpp.

{
        Refresh();
        ((MutLogicWnd*)GetParent())->CorrectScroller();
        event.Skip();
}

void MutApp::OnInitCmdLine ( wxCmdLineParser & parser )

Initialize command line arguments.

Definiert in Zeile 434 der Datei MutApp.cpp.

Benutzt _().

                                                   {
        const wxCmdLineEntryDesc cmdLineDesc[] = {
                { wxCMD_LINE_PARAM,  NULL, NULL, _("logic file"), 
                  wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE|wxCMD_LINE_PARAM_OPTIONAL },
                { wxCMD_LINE_NONE }
        };

        wxApp::OnInitCmdLine(parser);
        parser.SetDesc(cmdLineDesc);

#ifdef DEBUG
        debugFlags::InitCommandLine(parser);
#endif

        
}

void MutTag::OnLeftDown ( wxMouseEvent & event )

Definiert in Zeile 318 der Datei MutLogicWnd.cpp.

Benutzt CM_MUTTAG.

{
        wxCommandEvent event1(wxEVT_COMMAND_MENU_SELECTED, CM_MUTTAG);
        event1.SetEventObject(this);
        //((MutLogicWnd*)GetParent())->UpDate(GetKey(), GetIsLogic());
        wxPostEvent(GetParent(),event1);
        event.Skip();
}

void MutApp::OnMRUFile ( wxCommandEvent & event )

add handling of last files.

Definiert in Zeile 499 der Datei MutApp.cpp.

Benutzt _().

{
    int n = event.GetId() - wxID_FILE1;  // the index in MRU list
    wxString filename(document_manager.GetHistoryFile(n));
    if ( !filename.empty() )
    {
        // verify that the file exists before doing anything else
        if ( wxFile::Exists(filename) )
        {
            // try to open it
            if (!document_manager.CreateDocument(filename, wxDOC_SILENT))
            {
                // remove the file from the MRU list. The user should already be notified.
                document_manager.RemoveFileFromHistory(n);

                wxLogError(_("The file '%s' couldn't be opened.\nIt has been removed from the most recently used files list."),
                       filename.c_str());
            } else {
                    wxView * v = document_manager.GetCurrentView();
                    if (v) {
                            wxWindow * w = v->GetFrame();
                            if (w) {
                                    w->Raise();
                            }
                    }
            }
        }
        else
        {
            // remove the bogus filename from the MRU list and notify the user
            // about it
            document_manager.RemoveFileFromHistory(n);

            wxLogError(_("The file '%s' doesn't exist and couldn't be opened.\nIt has been removed from the most recently used files list."),
                       filename.c_str());
        }
    }
}

void MutFrame::OnPaint ( wxPaintEvent & event )

Hande paint events for Document/View framework.

This function call the paint function

Definiert in Zeile 689 der Datei MutFrame.cpp.

Benutzt STUBC.

{
    wxPaintDC dc(this);

    STUBC; 
/* this code is just copied and must be changed 
  to paint into the subwindow which is managed by 
  the AUI manager.

  Propably it must be simply moved to the client window.
*/
    
    if (m_childView) 
            m_childView->OnDraw(&dc);
}

void MutFrame::OnSize ( wxSizeEvent & event )

Definiert in Zeile 1871 der Datei MutFrame.cpp.

{
        event.Skip();
}

void MutLogicWnd::OnSize ( wxSizeEvent & event )

Definiert in Zeile 495 der Datei MutLogicWnd.cpp.

Benutzt MutLogicWnd::DoLayout().

{
        //  wxScrolledWindow::EvSize(sizeType, size);
        event.Skip();
        DoLayout();
}

void MutPanel::OnSize ( wxSizeEvent & event )

Definiert in Zeile 167 der Datei Panel.cpp.

{
    if (GetAutoLayout())
        Layout();
#if wxUSE_CONSTRAINTS
#if defined(__WXPM__) && 0
    else
    {
        // Need to properly move child windows under OS/2

        PSWP                        pWinSwp = GetSwp();

        if (pWinSwp->cx == 0 && pWinSwp->cy == 0 && pWinSwp->fl == 0)
        {
            // Uninitialized

            ::WinQueryWindowPos(GetHWND(), pWinSwp);
        }
        else
        {
            SWP                     vSwp;
            int                     nYDiff;

            ::WinQueryWindowPos(GetHWND(), &vSwp);
            nYDiff = pWinSwp->cy - vSwp.cy;
            MoveChildren(nYDiff);
            pWinSwp->cx = vSwp.cx;
            pWinSwp->cy = vSwp.cy;
        }
    }
#endif
#endif // wxUSE_CONSTRAINTS

    event.Skip();
}

bool MutFrame::OpenFile	(	wxString	path,
		bool	newfile = `false`
	)

Opens the given file, if we don't have a client yet.

open a file in a new frame.

Parameter:

path	Path of the file to open

Noch zu erledigen:: file loading fails silently if it is not in the systems encoding.

Definiert in Zeile 786 der Datei MutFrame.cpp.

Benutzt _(), APPNAME, MutFrame::client, mutaborGUI::MutEditFile::LoadFile(), MutFrame::SetClient() und STUBC.

Wird benutzt von MutFrame::CmFileNew(), MutFrame::CmFileOpen() und MutApp::CmFileOpen().

{
        STUBC;
        return false;

        if (client) return false;

        wxString filename = !path ? wxString(_("noname.mut"))
                            : wxFileName(path).GetFullName();

        MutEditFile * editor = new MutEditFile(this, wxPoint(0, 0), wxDefaultSize);

#ifdef DEBUG
        std::cout << "MutFrame::OpenFile(): Loading " << (path.fn_str()) << std::endl;

#endif
        if (!(!path))
                editor->LoadFile(path);

        editor->SetSelection(0, 0);
        SetTitle(wxString().Format(_("%s -- %s"),APPNAME,filename.c_str()));

        return SetClient(editor,filename);
}

WinKind operator++	(	WinKind &	k,
		int
	)		`[inline]`

Definiert in Zeile 45 der Datei MutTextBox.h.

{
        WinKind l=k;
        ++k;
        return l;
}

WinKind operator++ ( WinKind & k ) [inline]

Definiert in Zeile 40 der Datei MutTextBox.h.

{
        return k = WinKind(int(k) + 1);
}

void MutApp::PassEventToDocManagerCMD ( wxCommandEvent & event )

Pass event to document manager.

Definiert in Zeile 486 der Datei MutApp.cpp.

Benutzt DEBUGLOG.

{
        DEBUGLOG(eventqueue,_T("Command"));
        if (!document_manager.ProcessEvent(event)) 
                event.Skip();
}

void MutApp::PassEventToDocManagerUPD ( wxUpdateUIEvent & event )

Definiert in Zeile 492 der Datei MutApp.cpp.

Benutzt DEBUGLOG.

{
        DEBUGLOG(eventqueue,_T("UpdateUI"));
        if (!document_manager.ProcessEvent(event)) 
                event.Skip();
}

void MutFrame::PassEventToEditor ( wxCommandEvent & event )

passes an event to the editor.

This function is used to pass one event to the client window.

Parameter:

event Event to be passed

Definiert in Zeile 611 der Datei MutFrame.cpp.

Benutzt MutFrame::client.

Wird benutzt von MutFrame::CmFileOpen().

{
        event.Skip(false);

        if (dynamic_cast<MutEditFile*>(client)) {
                wxPostEvent(client,event);
        }
}

bool MutApp::ProcessEvent ( wxEvent & event ) [virtual]

Definiert in Zeile 476 der Datei MutApp.cpp.

Benutzt DEBUGLOG.

{
        bool retval =  wxApp::ProcessEvent(event);
#ifdef DEBUG
        if (!retval)
                DEBUGLOG(eventqueue,_T("Unhandled event: Type %d"), event.GetEventType());
#endif
        return retval;
}

void MutFrame::RaiseLogic ( wxCommandEvent & event )

Definiert in Zeile 1030 der Datei MutFrame.cpp.

Benutzt MutFrame::boxCommandIds, curBox, DEBUGLOG, MAX_BOX, muT, MutFrame::RaiseTheFrame(), WinAttrs und WK_LOGIC.

Wird benutzt von MutFrame::UpdateBoxMenu().

{
        if (!RaiseTheFrame()) {
                DEBUGLOG (other, _T("Calling Logic frame for id %d"), event.GetId());
                theFrame -> RaiseLogic(event);
                return;
        }

        DEBUGLOG (other, _T("Reached logic frame"));

        wxASSERT(theFrame == this);
        DEBUGLOG (other, _T("%d"),event.GetId());

        size_t i = 0;

        while (i < MAX_BOX && boxCommandIds[i] != event.GetId()) i++;

        wxASSERT(i!=MAX_BOX);

        DEBUGLOG (other, _T("%d"),i);

        curBox = i;

        if (WinAttrs[WK_LOGIC][i].Win) {
                WinAttrs[WK_LOGIC][i].Win->SetFocus();

                wxFrame * win =
                        dynamic_cast<wxFrame *>(WinAttrs[WK_LOGIC][i].Win->GetParent());

                if (win) win->Raise();

                DEBUGLOG (other, _T("Parent type: %s"), muT(typeid(*( WinAttrs[WK_LOGIC][i].Win->GetParent())).name()).c_str());

                GetMenuBar()->Check(event.GetId(),true);
        }
}

bool MutFrame::RaiseTheFrame ( )

Definiert in Zeile 1980 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::RaiseLogic().

{
        if (this == theFrame) return true;

        theFrame->Raise();

        return false;
}

static void MutFrame::repaint_route ( ) [inline, static]

Definiert in Zeile 337 der Datei MutFrame.h.

Benutzt MutFrame::client und WK_ROUTE.

Wird benutzt von MutFrame::CmDoActivate(), MutFrame::CmInDevPause(), MutFrame::CmInDevPlay(), MutFrame::CmInDevStop(), MutFrame::DoStop() und MutFrame::UpdateUI().

        {
                MutFrame * routewin = dynamic_cast<MutFrame *>(FindWindowById(WK_ROUTE));

                if (routewin) {
                        MutRouteWnd * route = dynamic_cast<MutRouteWnd *> (routewin->client);

                        if (route) route->Refresh();
                }
        }

void MutFrame::RestoreState ( )

Definiert in Zeile 1609 der Datei MutFrame.cpp.

Benutzt Get().

Wird benutzt von IMPLEMENT_APP().

{
        //  int DeskMax = 1, WinMax = 2, HelpMax = 0;
        wxConfigBase *config = wxConfig::Get();
        
/* TODO: implement this in a robust way. The current implementation does not check that the window is inside the accesible area of the screen.
        int x=0, y=0, w=0, h=0;

        config->SetPath(_T("Desktop"));
        //  DeskMax=config->Read(_T("DeskMax"),0l);

        if ((x=config->Read(_T("X Position"),0l)) &&
                        (y=config->Read(_T("Y Position"),0l)) &&
                        (w=config->Read(_T("Width"),0l)) &&
                        (h=config->Read(_T("Height"),0l))) {
                SetSize(x, y, w, h);

#ifdef DEBUG
                std::cerr << "x=" << x << ", y=" << y << ", w=" << w << ", h=" << h << std::endl;
#endif
        }

        config->SetPath(_T(".."));
*/
        //  wxLogWarning(_("MutFrame::RestoreState() doesn't handle multiple windows"));
}

void MutApp::RestoreState ( )

Load global state.

Load the current global settings in the registry or configuration file.

Definiert in Zeile 1373 der Datei MutApp.cpp.

Benutzt _(), asTS, MutApp::document_manager, Get(), LoadRoutes(), MAX_BOX, SaveEditor, TextBoxWanted, UseColorBars, WK_ACT, WK_KEY und WK_TS.

{
        /* \todo restore Windows of last session. */
        wxConfigBase *config = wxConfig::Get();
        if (!config) {
                wxLogError(_("Could not get configuration storage"));
                return;
        }

        wxString oldpath = config->GetPath();

        config->SetPath(_T("/Settings"));
        config->Read(_T("ToneSystem"), &asTS, true);
        config->Read(_T("SaveEditor"), &SaveEditor, true);
        config->Read(_T("ColorBars"), &UseColorBars, true);

        config->SetPath(_T("Box settings"));

        for (size_t box = 0 ; box < MAX_BOX ; box++) {
                config->SetPath(wxString::Format(_T("%d"),box));
                config->Read(_T("KeyWindow"), &TextBoxWanted[box][WK_KEY], false);
                config->Read(_T("ToneSystemWindow"), &TextBoxWanted[box][WK_TS], false);
                config->Read(_T("ActionsWindow"), &TextBoxWanted[box][WK_ACT], false);
                config->SetPath(_T(".."));
        }

        config->SetPath(_T(".."));

        config->SetPath(_T("DocManager"));
        document_manager.FileHistoryLoad(*config);
        config->SetPath(_T(".."));

        LoadRoutes(config);
        config->SetPath(oldpath);
}

void MutFrame::SaveState ( )

Definiert in Zeile 1571 der Datei MutFrame.cpp.

Benutzt Get().

Wird benutzt von MutFrame::OnClose().

{
        wxConfigBase *config = wxConfig::Get();

        wxPoint pos = GetPosition();
        wxSize size = GetSize();
        int DeskMax = size.GetWidth() < GetClientSize().GetWidth();
        config->SetPath(_T("Desktop"));
        config->Write(_T("X Position"),pos.x);
        config->Write(_T("Y Position"),pos.y);
        config->Write(_T("Width"),size.GetWidth());
        config->Write(_T("Height"),size.GetHeight());
        config->Write(_T("DeskMax"),DeskMax);

        config->SetPath(_T(".."));
}

void MutApp::SaveState ( )

Save global state.

Save the current global settings in the registry or configuration file.

Definiert in Zeile 1337 der Datei MutApp.cpp.

Benutzt _(), asTS, MutApp::document_manager, Get(), MAX_BOX, SaveEditor, SaveRoutes(), TextBoxWanted, UseColorBars, WK_ACT, WK_KEY und WK_TS.

Wird benutzt von MutApp::OnExit().

{
        /* \todo save Parameters of all open windows */
        wxConfigBase *config = wxConfig::Get();
        if (!config) {
                wxLogError(_("Could not get configuration storage"));
                return;
        }

        wxString oldpath = config->GetPath();

        config->SetPath(_T("/Settings"));
        config->Write(_T("Tone system"), asTS);
        config->Write(_T("Save editor"), SaveEditor);
        config->Write(_T("Color bars"), UseColorBars);

        config->SetPath(_T("Box settings"));

        for (size_t box = 0 ; box < MAX_BOX ; box++) {
                config->SetPath(wxString::Format(_T("%d"),box));
                config->Write(_T("KeyWindow"), TextBoxWanted[box][WK_KEY]);
                config->Write(_T("ToneSystemWindow"), TextBoxWanted[box][WK_TS]);
                config->Write(_T("ActionsWindow"), TextBoxWanted[box][WK_ACT]);
                config->SetPath(_T(".."));
        }

        config->SetPath(_T(".."));

        config->SetPath(_T("DocManager"));
        document_manager.FileHistorySave(*config);
        config->SetPath(_T(".."));

        SaveRoutes(config);
        config->SetPath(oldpath);
}

bool MutFrame::SetClient	(	wxWindow *	win,
		const wxString &	title
	)

Attach a client to the Frame.

Attach a client.

Parameter:

window to be attached as the client.

Definiert in Zeile 815 der Datei MutFrame.cpp.

Benutzt MutFrame::auimanager, MutFrame::client und DEBUGLOG.

Wird benutzt von MutFrame::OpenFile().

{
        if (client || !win) {
                wxASSERT(!client);
                wxASSERT(win);
                return false;
        }
        
        DEBUGLOG(docview,_T("Setting client of %x to %x with title '%s'"),
                 this,
                 win,
                 (char *)title.c_str());

        client = win;
        SetTitle(title);
        auimanager.AddPane(client,wxAuiPaneInfo().
                           Caption(title).CenterPane().PaneBorder(false));
        auimanager.Update();
        return true;
}

void MutFrame::SetEditMenu ( wxMenu * e ) [inline]

Definiert in Zeile 349 der Datei MutFrame.h.

Benutzt MutFrame::editmenu.

{ editmenu = e; }

void MutFrame::SetFileMenu ( wxMenu * f ) [inline]

Definiert in Zeile 348 der Datei MutFrame.h.

Benutzt MutFrame::filemenu.

Wird benutzt von MutApp::InitMainFrame().

{ filemenu = f; }

void MutFrame::SetStatus ( int WXUNUSEDimgNr ) [inline]

Definiert in Zeile 321 der Datei MutFrame.h.

Wird benutzt von MutFrame::CeInDevPause(), MutFrame::CmDoActivate(), MutFrame::CmInDevPause(), MutFrame::CmInDevPlay(), MutFrame::CmInDevStop(), MutFrame::DoStop() und MutFrame::StopInDev().

        {
                //StatusGadget->SelectImage(curStatusImg = imgNr, true);
        }

void MutApp::ShowHelp ( int commandId )

Show the helpwindow on the page associated with a certain command id.

This function opens a help window according to the current command id.

Parameter:

commandId wxWidgets command id to open help window for.

Definiert in Zeile 896 der Datei MutApp.cpp.

Benutzt _(), CM_HELPCOMMON und HelpController.

Wird benutzt von MutApp::CmHelp().

{
        switch (commandId) {

        case CM_HELPINDEX:
                HelpController->DisplayContents();

                break;

        case CM_HELP:
                HelpController->Display(_("help.html"));

                break;

        case CM_SETUP:
                HelpController->Display(_("The setup dialog"));

                break;

        case CM_HELPHANDBOOK:
                HelpController->Display(_("manual.html"));

                break;

        case CM_HELPREFERENCE:
                HelpController->Display(_("reference.html"));

                break;

        case CM_HELPONHELP:
                HelpController->Display(_("Help window"));

                break;

        case CM_HELPCOMMON:
                HelpController->DisplayContents();

                break;

        case CM_HELPSEARCH: {
                wxString key = wxGetTextFromUser(_("Search for?"),
                                                 _("Search help for keyword"),
                                                 wxEmptyString,
                                                 GetTopWindow());

                if (! key.IsEmpty())
                        HelpController->KeywordSearch(key);
        }

        break;
        }
}

int SmallestBoxUsed ( )

Definiert in Zeile 2008 der Datei MutFrame.cpp.

Benutzt InDevice::GetDeviceList(), Route::GetNext(), InDevice::GetNext() und MAX_BOX.

{
  int Box = MAX_BOX; // unused value

        for (InDevice *In = InDevice::GetDeviceList(); In; In = In->GetNext())
          for (Route *R = In->GetRoutes(); R; R = R->GetNext())
            if ( R->Box >= 0 )
              Box = STD_PRE::min(Box, R->Box);

        if ( Box == MAX_BOX )
                return 0;
        else
                return Box;
}

void MutFrame::StopInDev ( )

Definiert in Zeile 1638 der Datei MutFrame.cpp.

Benutzt InDevice::GetDeviceList(), InDevice::GetNext(), LogicOn, MutaborDevicePause, MutaborDevicePlay und MutFrame::SetStatus().

Wird benutzt von MutFrame::CmInDevStop() und MutFrame::DoStop().

{
        int nr = 0;

        for ( InDevice *In = InDevice::GetDeviceList(); In; In = In->GetNext(), 
                nr++)
          if ( In->GetMode() == MutaborDevicePlay || In->GetMode() == MutaborDevicePause ) {
            //      In->Mode = MutaborDeviceStop;
            //          InDeviceAction(nr, In->Mode);
            In->Stop();
          }

        SetStatus(1-LogicOn);
}

void MutFrame::TextBoxOpen	(	WinKind	kind,
		int	box
	)

Definiert in Zeile 1247 der Datei MutFrame.cpp.

Benutzt _(), asTS, MutFrame::auimanager, CAW, MutFrame::client, DEBUGLOG, GenerateACTString(), GenerateCAWString(), GetKeyString(), MutTextBox::GetKind(), GetTSString(), GetWinAttr(), muT, MutTextBox::NewText(), WK_ACT, WK_EDIT, WK_KEY, WK_LOGIC, WK_NULL, WK_ROUTE und WK_TS.

Wird benutzt von MutFrame::CmDoActivate(), MutFrame::CmToggleCAW(), MutFrame::CmToggleOWM() und MutFrame::ToggleTextBox().

{
        DEBUGLOG (other, _T("%d,%d"),kind,box);

        char *s = NULL;
        wxString title;

        switch ( kind ) {

        case WK_KEY:
                s = GetKeyString(box, asTS);

                title.Printf(_("Current keys at Box %d"),box);

                break;

        case WK_TS:
                s = GetTSString(box, asTS);

                title.Printf(_("Current tone system at Box %d"),box);

                break;

        case WK_ACT:
                if (CAW) {
                        s = GenerateCAWString();
                        title=_("Action log");
                } else {
                        s = GenerateACTString(box);
                        title.Printf(_("Actions at Box %d"),box);
                }

                break;

        case WK_LOGIC:
                wxLogWarning(_("Unexpected value: WK_LOGIC"));

                break;

        case WK_ROUTE:
                wxLogWarning(_("Unexpected value: WK_ROUTE"));

                break;

        case WK_EDIT:
                wxLogWarning(_("Unexpected value: WK_EDIT"));

                break;

        case WK_NULL:
                wxLogWarning(_("Unexpected value: WK_NULL"));

                break;

        default:
                wxLogError(_("Unexpected window kind: %d"), kind);
        }

        int width, height;

        GetClientSize(&width, &height);
        width /= 2;
        height /= 2;

        WinAttr *attr = GetWinAttr(kind, box);
        MutTextBox *client = new MutChild(kind,
                                          attr,
                                          this,
                                          -1,
                                          wxDefaultPosition,
                                          wxSize(width, height));
        DEBUGLOG (other, _T("client->winKind=%d"),client->GetKind());
        DEBUGLOG (other, _T("s:= %s"),s);
        DEBUGLOG (other, _T("client->winKind=%d"),client->GetKind());

        wxString str;

        if (s)
                str = muT(s);
        else
                str = wxEmptyString;

        DEBUGLOG (other, _T("client->winKind=%d"),client->GetKind());

        auimanager.AddPane(client,wxAuiPaneInfo().Caption(title)
                           .CloseButton(true).MaximizeButton(true)
                           .Float()
                           .Name(wxString::Format(_T("WK_%d_%d"),kind,box)));

        DEBUGLOG (other, _T("client->winKind=%d"),client->GetKind());

        client->NewText(str, true);

        DEBUGLOG (other, _T("client->winKind=%d"),client->GetKind());

        auimanager.Update();
}

void MutFrame::ToggleTextBox ( WinKind kind )

Definiert in Zeile 1207 der Datei MutFrame.cpp.

Benutzt MutFrame::auimanager, curBox, Get(), IsOpen(), LogicOn, MutFrame::TextBoxOpen(), TextBoxWanted, MutFrame::ToggleTextBox() und WinAttr::Win.

Wird benutzt von MutFrame::CmToggleAct(), MutFrame::CmToggleKey(), MutFrame::CmToggleTS() und MutFrame::ToggleTextBox().

{
#ifdef DEBUG
        std::cerr << "MutFrame::ToggleTextBox: kind: " << kind << std::endl
        << "MutFrame::ToggleTextBox: TextBoxWanted:"
        << TextBoxWanted[curBox][kind] << std::endl;
#endif

        if (theFrame && (theFrame != this)) {
                theFrame->ToggleTextBox(kind);
                return;
        }


        TextBoxWanted[curBox][kind] = !TextBoxWanted[curBox][kind];

#ifdef DEBUG
        std::cerr << "MutFrame::ToggleTextBox: LogicOn"
        << LogicOn << std::endl;
#endif

        if ( !LogicOn ) return;

#ifdef DEBUG
        std::cerr << "MutFrame::ToggleTextBox: IsOpen(kind, curBox)"
        << IsOpen(kind, curBox) << std::endl;

#endif
        if ( IsOpen(kind, curBox) ) {
                wxWindow *win = Get(kind, curBox)->Win;
                //Get(kind, curBox)->Win->SendMessage(WM_CLOSE);
                auimanager.DetachPane(win);
                win->Close();
                auimanager.Update();
                //win->Close();
                //win->Destroy();
        } else
                TextBoxOpen(kind, curBox);
}

void MutLogicWnd::UpDate	(	int	thekey,
		bool	isLogicKey
	)

Definiert in Zeile 613 der Datei MutLogicWnd.cpp.

Benutzt _(), BoxColor(), MutLogicWnd::boxnumber, CM_UPDATEUI, MutLogicWnd::ColorBar1, MutLogicWnd::ColorBar2, curLogic, curTaste, curTS, MutLogicWnd::DoLayout(), GetMutTag(), KeyboardAnalyse(), muT, MutLogicWnd::nTags, MutLogicWnd::Ok und UseColorBars.

Wird benutzt von MutLogicWnd::CmBox(), MutLogicWnd::CmMutTag() und MutLogicWnd::CmTaste().

{
        // Analyse zuerst
        KeyboardAnalyse(boxnumber, thekey, isLogicKey);
        curTaste[boxnumber][isLogicKey] = thekey;
        wxWindow *ToFocus = NULL;

        if ( isLogicKey )
                curTaste[boxnumber][0] = 0;

        // alte TMutTag-s lˆschen
        DestroyChildren();

        // neue erstellen
        char isLogic, s[200], s1[200], key, isOpen;

        wxString sText, sEinst;

        wxWindow *aWin;

        nTags = 0;

        if ( GetMutTag(isLogic, s, s1, key, boxnumber) )
                do {
                        nTags++;
                        sText = muT(s);
                        sEinst = muT(s1);

                        if ( (isOpen = (key == curTaste[boxnumber][(size_t)isLogic])) != 0 ) {
                                if ( isLogic ) {
                                        curLogic[boxnumber] = sText;

                                        if ( !sEinst.IsEmpty() )
                                                curTS[boxnumber] = sEinst;
                                        else if ( !curTS[boxnumber] )
                                                curTS[boxnumber] = _("(INITIAL)");
                                        else if ( curTS[boxnumber][0] != '[' )
                                                curTS[boxnumber] = wxString::Format(_T("[%s]"), curTS[boxnumber].c_str());
                                } else
                                        curTS[boxnumber] = sText;
                        }

                        aWin = new MutTag(this, wxDefaultPosition, isLogic, isOpen, key, sText);

                        if ( isOpen ) ToFocus = aWin;
                } while ( GetMutTag(isLogic, s, s1, key) );

        // Color Bars
        if ( UseColorBars ) {
                wxColour BarColor = BoxColor(boxnumber);
                ColorBar1 = new wxWindow(this, -1, wxPoint(0, 0), wxSize(2,2));
                ColorBar1->SetBackgroundColour(BarColor);
                ColorBar1->Disable();
                ColorBar2 = new wxWindow(this, -1, wxPoint(0, 0), wxSize(2,2));
                ColorBar2->SetBackgroundColour(BarColor);
                ColorBar2->Disable();
        } else {
                ColorBar1 = 0;
                ColorBar2 = 0;
        }

        // neue TMutTag-s aktivieren
        //CreateChildren();
        // Fokus setzen
#if 0
        if ( !ToFocus )
                ToFocus = GetChildren().GetFirst()->GetData();
#endif

        if ( ToFocus && FindFocus() != ToFocus)
                ToFocus->SetFocus();

        // Tags anordnen
        DoLayout();

        wxCommandEvent event1(wxEVT_COMMAND_MENU_SELECTED,
                              CM_UPDATEUI);
        GetParent()->GetEventHandler()->ProcessEvent(event1);
        Ok = true;
}

void MutFrame::UpdateBoxMenu ( )

Definiert in Zeile 1933 der Datei MutFrame.cpp.

Benutzt _(), MutFrame::boxCommandIds, BoxUsed, MutFrame::ClearMenuItem(), CM_SELECTBOX, curBox, DEBUGLOG, MutFrame::LogicWinOpen(), MAX_BOX, name und MutFrame::RaiseLogic().

Wird benutzt von MutFrame::CmDoActivate() und MutFrame::CmRoutes().

{
#ifdef DEBUG
        std::cout << "MutFrame::CmDoActivate: Set Box selection menu" << std::endl;
#endif
        wxMenuItem * boxSelector = ClearMenuItem(CM_SELECTBOX);
        wxASSERT(boxSelector->IsSubMenu());
        wxMenu * boxMenu = boxSelector->GetSubMenu();
        wxASSERT(boxMenu);
        DEBUGLOG (other, _T("boxMenu = %p"),boxMenu);
        //  wxID_HIGHEST
        //  wxMenu *

        for (int i = 0, j=0; i < MAX_BOX; i++) {
                if (BoxUsed[i]) {
                        if (theFrame == this) LogicWinOpen(i);

                        if (!boxCommandIds[i]) {
                                boxCommandIds[i]=wxNewId();
                                DEBUGLOG (other, _("Box %d got id %d"),i,boxCommandIds[i]);
                        }

                        DEBUGLOG (other, _("Currently %d items in box menu"),boxMenu->GetMenuItemCount());

                        DEBUGLOG (other, _("Appending menu for box %d with id %d"),i,boxCommandIds[i]);
                        wxString name = wxString::Format(_("Select box %d\tCtrl+%d"),i,i);
                        wxString description = wxString::Format(_("Select box %d as the active Box for box specific commands."),i);
                        wxASSERT(!(GetMenuBar()->FindItem(boxCommandIds[i])));
                        wxMenuItem * item = new wxMenuItem(boxMenu,boxCommandIds[i],
                                                           name,
                                                           description,
                                                           wxITEM_RADIO);
                        boxMenu->Append(item);

                        if (i == curBox) boxMenu->Check(boxCommandIds[i],true);

                        DEBUGLOG (other, _("Connecting command with id %d for box %d"),
                                 i,boxCommandIds[i]);

                        Connect( boxCommandIds[i],
                                 wxEVT_COMMAND_MENU_SELECTED,
                                 wxCommandEventHandler(MutFrame::RaiseLogic) );

                }
        }
}

void MutFrame::UpdateUI ( wxCommandEvent & WXUNUSEDevent )

Update GUI when the mutabor kernel or file players have acted.

Definiert in Zeile 1771 der Datei MutFrame.cpp.

Benutzt _(), ACTChanged(), asTS, WinAttr::Box, CAW, curBox, GenerateACTString(), GenerateCAWString(), Get(), InDevice::GetDeviceList(), GetKeyString(), InDevice::GetNext(), GetTSString(), InDevicesChanged(), KeyChanged(), MutaborDeviceCompileError, MutaborDeviceStop, MutaborDeviceTimingError, RealTime, MutFrame::repaint_route(), TakeOverAktions(), TSChanged(), WinAttr::Win, WinAttrs, WK_ACT, WK_KEY und WK_TS.

{
        for (size_t i = 0; i < WinAttrs[WK_KEY].GetCount(); i++) {
                WinAttr *winAttr = &WinAttrs[WK_KEY][i];

                if ( winAttr->Win && KeyChanged(winAttr->Box) )
                        ((MutTextBox*)winAttr->Win)->
                        NewText(GetKeyString(winAttr->Box, asTS), 1);
        }

        for (size_t i = 0; i < WinAttrs[WK_TS].GetCount(); i++) {
                WinAttr *winAttr = &WinAttrs[WK_TS][i];

                if ( winAttr->Win && TSChanged(winAttr->Box) )
                        ((MutTextBox*)winAttr->Win)->
                        NewText(GetTSString(winAttr->Box, asTS), 1);
        }

        // Aktionen
        if ( TakeOverAktions() )
        {
                if ( CAW ) {
                        WinAttr *winAttr = Get(WK_ACT, curBox);

                        if ( winAttr && winAttr->Win )
                                ((MutTextBox*)winAttr->Win)->NewText(GenerateCAWString(), 1);
                } else {
                        for (size_t i = 0; i < WinAttrs[WK_ACT].GetCount(); i++) {
                                WinAttr *winAttr = &WinAttrs[WK_ACT][i];

                                if ( winAttr->Win && ACTChanged(winAttr->Box) )
                                        ((MutTextBox*)winAttr->Win)->
                                        NewText(GenerateACTString(winAttr->Box), 1);
                        }
                }
        }
        // Zeilen/Spalte
        /*  if ( ActiveWinKind == WK_EDIT )
            {
            TMDIChild* curChild = Client->GetActiveMDIChild();
            if ( curChild )
            curChild->SendMessage(WM_COMMAND, CM_GETLINE);
            }
            else
            EditLine = -1;
            if ( EditLine != oldEditLine || EditRow != oldEditRow )
            {
            char s[10] = "";
            if ( EditLine != -1 ) sprintf(s, "%d:%d", EditLine, EditRow);
            IndikatorGadget->SetText(s);
            oldEditLine = EditLine; oldEditRow = EditRow;
            }*/


        if ( InDevicesChanged() ) {
                bool NRT_Finish = false;


                for (InDevice *In = InDevice::GetDeviceList(); In; In = In->GetNext()) {
                  if ( !In || In->GetMode() == MutaborDeviceCompileError ) continue;
                  if ( In->GetMode() ==  MutaborDeviceTimingError ) {
                    In->SetMode(MutaborDeviceStop);
                    In->Stop();
                    NRT_Finish = !RealTime;
                  }
                }

                repaint_route();

                if ( !RealTime )
                        wxMessageBox(_("Translation in batch mode completed. Output was generated."),
                                     _("Batch translation finished"), wxOK);
        }
}

void UpdateUIcallback	(	int	box,
		bool	logic_changed
	)

Definiert in Zeile 840 der Datei MutFrame.cpp.

Benutzt CM_UPDATEUI.

Wird benutzt von MutFrame::CmDoActivate().

{
        // todo Update UI
        if ( theFrame ) {
                wxCommandEvent event1(wxEVT_COMMAND_MENU_SELECTED,
                                           CM_UPDATEUI);
                wxPostEvent(theFrame,event1);
        }
}

void MutFrame::WindowSize ( MutChild * win )

Definiert in Zeile 1472 der Datei MutFrame.cpp.

Benutzt _(), demo, NumberOfOpen(), MutTextBox::winAttr, MutTextBox::winKind, WK_ACT, WK_KEY, WK_LOGIC, WK_ROUTE und WK_TS.

{
        wxLogWarning(_("MutFrame::WindowSize:  not implemented" ));
#if 0

        if ( !subSize.IsFullySpecified() ) {
                wxScreenDC *sdc = new wxScreenDC();
                wxSize deskSize = sdc->GetSize();
                delete sdc;
                subSize.Set(0, 0);

                for (int i = 0; i < 4; i++)
                        if ( deskSize.GetWidth() == WSize[i][0] )
                                subSize.Set(WSize[i][1], WSize[i][2]);
        }

        if ( win->winAttr->W ) {
                win->SetSize(win->winAttr->X, win->winAttr->Y,
                             win->winAttr->W, win->winAttr->H);
        } else {
                int w, h;
                GetClientSize(&w, &h);
                // get size of editor window
                int w1 = w * 4 / 5, h1 = h * 2 / 3;

                if ( subSize.GetWidth() != 0 ) {
                        w1 = subSize.GetWidth();
                        h1 = subSize.GetHeight();
                }

                if ( w - w1 < 112 )
                        w1 = w - 112;

                int n = (NumberOfOpen(win->winKind)-1)*22;

                if ( demo )
                        switch ( win->winKind ) {

                        case WK_KEY:
                                win->SetSize(w / 2-n, n, w / 4, h / 2);

                                break;

                        case WK_TS:
                                win->SetSize(w / 2 + w / 4-n, n, w / 4, h);

                                break;

                        case WK_ACT:
                                win->SetSize(w / 2 + n, h / 2-n, w / 4, h - h / 2);

                                break;

                        case WK_LOGIC:
                                win->SetSize(n, n, w / 2, h);

                                break;

                        case WK_ROUTE:
                                win->SetSize(n, n, w / 2, h);

                                break;
                        }
                else
                        switch ( win->winKind ) {

                        case WK_KEY:
                                win->SetSize(w1-n, n, w - w1, h / 2);

                                break;

                        case WK_TS:
                                win->SetSize(w1-n, h / 2-n, w - w1, h - h / 2);

                                break;

                        case WK_ACT:
                                win->SetSize(w1 * 3 / 4-n, h1-n, w1 - w1 * 3 / 4, h - h1);

                                break;

                        case WK_LOGIC:
                                win->SetSize(n, h1-n, w1 * 3 / 4, h - h1);

                                break;

                        case WK_ROUTE:
                                win->SetSize(n, h1-n, w1 * 3 / 4, h - h1);

                                break;
                        };
        }

#endif
}

WX_DECLARE_HASH_MAP	(	wxFrame *	,
		wxFrame *	,
		wxPointerHash	,
		wxPointerEqual	,
		FrameHash
	)

Declare a frame array as an hash table.

WX_DECLARE_OBJARRAY	(	WinAttr	,
		ArrayOfWinAttr
	)

WX_DEFINE_OBJARRAY ( ArrayOfWinAttr )

MutChild::~MutChild ( )

Definiert in Zeile 131 der Datei MutChild.cpp.

Benutzt DEBUGLOG, MutChild::deleteFromWinAttrs(), MutTextBox::winKind, WK_KEY und WK_NULL.

{
        wxASSERT(WK_KEY <= winKind && winKind < WK_NULL);
        DEBUGLOG (other, _T(""));
        deleteFromWinAttrs();
}

MutFrame::~MutFrame ( ) [virtual]

Destructor.

Definiert in Zeile 551 der Datei MutFrame.cpp.

Benutzt MutFrame::auimanager, MutFrame::filemenu und mutaborGUI::MutView::SetTextsw().

{
        if (filemenu) {
                if (wxGetApp().GetDocumentManager()) 
                        wxGetApp().GetDocumentManager()->FileHistoryRemoveMenu(filemenu);
        }
        if (m_childView) {
                wxASSERT(dynamic_cast<MutView *>(m_childView));
                MutView * v = (MutView *) m_childView;
                v->SetFrame(NULL);
                v->SetTextsw(NULL);
        }
        auimanager.UnInit();

//      while (wxGetApp().Pending()) wxGetApp().Dispatch();
}

MutPanel::~MutPanel ( ) [virtual]

Definiert in Zeile 152 der Datei Panel.cpp.

{
}

Variablen-Dokumentation

wxBitmap MutToolBarBitmaps::About [static]

Definiert in Zeile 57 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

wxWindow* MutFrame::actionwindows[MAX_BOX] [private]

Definiert in Zeile 376 der Datei MutFrame.h.

MutFrame* MutFrame::ActiveWindow [static, private]

Definiert in Zeile 380 der Datei MutFrame.h.

bool asTS = true

Definiert in Zeile 311 der Datei MutFrame.cpp.

Wird benutzt von MutConfigDialog::MutConfigDialog(), MutApp::RestoreState(), MutApp::SaveState(), MutFrame::TextBoxOpen() und MutFrame::UpdateUI().

bool asTS

Definiert in Zeile 311 der Datei MutFrame.cpp.

Wird benutzt von MutConfigDialog::MutConfigDialog(), MutApp::RestoreState(), MutApp::SaveState(), MutFrame::TextBoxOpen() und MutFrame::UpdateUI().

wxAuiManager MutFrame::auimanager [private]

Definiert in Zeile 372 der Datei MutFrame.h.

Wird benutzt von MutFrame::CloseAll(), MutFrame::CloseClientWindow(), MutFrame::CmRoutes(), MutFrame::CmToggleCAW(), MutFrame::CmToggleOWM(), MutFrame::EventPassOn(), MutFrame::GetDockArt(), MutFrame::LogicWinOpen(), MutFrame::MutFrame(), MutFrame::SetClient(), MutFrame::TextBoxOpen(), MutFrame::ToggleTextBox() und MutFrame::~MutFrame().

int MutFrame::boxCommandIds [static, private]

Definiert in Zeile 382 der Datei MutFrame.h.

Wird benutzt von MutFrame::RaiseLogic() und MutFrame::UpdateBoxMenu().

bool BoxUsed[MAX_BOX]

which mutabor boxes are used at all?

Definiert in Zeile 1165 der Datei EDevice.cpp.

Wird benutzt von MutFrame::CmDoActivate() und MutFrame::UpdateBoxMenu().

bool BoxUsed[MAX_BOX]

which mutabor boxes are used at all?

Definiert in Zeile 1991 der Datei MutFrame.cpp.

bool CAW

Definiert in Zeile 315 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CeToggleCAW(), MutFrame::CmToggleCAW(), MutFrame::TextBoxOpen() und MutFrame::UpdateUI().

bool CAW = false

Definiert in Zeile 315 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CeToggleCAW(), MutFrame::CmToggleCAW(), MutFrame::TextBoxOpen() und MutFrame::UpdateUI().

wxWindow* ChildToClose = NULL

Definiert in Zeile 318 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CmCloseChild().

wxWindow* MutFrame::client [private]

Definiert in Zeile 378 der Datei MutFrame.h.

Wird benutzt von MutFrame::CeActivate(), MutFrame::CmFileNew(), MutFrame::CmFileOpen(), MutFrame::CmRoutes(), MutFrame::HasClient(), MutFrame::LogicWinOpen(), MutFrame::MutFrame(), MutFrame::OnEraseBackground(), MutFrame::OpenFile(), MutFrame::PassEventToEditor(), MutFrame::repaint_route(), MutFrame::SetClient() und MutFrame::TextBoxOpen().

MutEditFile::CmCompile MutEditFile::CmCompAct MutEditFile::CmHelpContext MutEditFile::OnEditClear MutEditFile::OnEditCopy MutEditFile::OnEditIndentInc MutEditFile::OnEditSelectAll MutEditFile::OnEditRedo MutEditFile::OnFind MutEditFile::OnReplace MutEditFile::OnBraceMatch CM_HILIGHTLAST

Definiert in Zeile 129 der Datei MutEditFile.cpp.

CompDlg* CompDia = NULL

Definiert in Zeile 93 der Datei MutEditFile.cpp.

wxString CompiledFile

Definiert in Zeile 320 der Datei MutFrame.cpp.

Wird benutzt von MutLogicWnd::CmBox().

wxString CompiledFile

Definiert in Zeile 320 der Datei MutFrame.cpp.

Wird benutzt von MutLogicWnd::CmBox().

wxBitmap MutToolBarBitmaps::Copy [static]

Definiert in Zeile 47 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

int curBox

Definiert in Zeile 317 der Datei MutFrame.cpp.

int curBox = 0

Definiert in Zeile 317 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CeToggleAct(), MutFrame::CeToggleKey(), MutFrame::CeToggleTS(), MutFrame::CmDoActivate(), MutFrame::CmToggleCAW(), MutFrame::CmToggleOWM(), MutChild::OnActivate(), MutTextBox::OnClose(), MutFrame::RaiseLogic(), MutFrame::ToggleTextBox(), MutFrame::UpdateBoxMenu() und MutFrame::UpdateUI().

wxString curLogic[MAX_BOX]

Definiert in Zeile 322 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CmDoActivate() und MutLogicWnd::UpDate().

wxString curLogic[MAX_BOX]

Definiert in Zeile 322 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CmDoActivate() und MutLogicWnd::UpDate().

int MutFrame::curStatusImg [private]

Definiert in Zeile 370 der Datei MutFrame.h.

Wird benutzt von MutFrame::CeInDevPause().

int curTaste[MAX_BOX][2]

Definiert in Zeile 324 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CmDoActivate() und MutLogicWnd::UpDate().

int curTaste[MAX_BOX][2]

Definiert in Zeile 324 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CmDoActivate() und MutLogicWnd::UpDate().

wxString curTS[MAX_BOX]

Definiert in Zeile 323 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CmDoActivate() und MutLogicWnd::UpDate().

wxString curTS[MAX_BOX]

Definiert in Zeile 323 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CmDoActivate() und MutLogicWnd::UpDate().

wxBitmap MutToolBarBitmaps::Cut [static]

Definiert in Zeile 48 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

bool demo = false

Definiert in Zeile 309 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::WindowSize().

wxMenu* MutFrame::editmenu [private]

Definiert in Zeile 352 der Datei MutFrame.h.

Wird benutzt von MutFrame::MutFrame() und MutFrame::SetEditMenu().

wxMenu* MutFrame::filemenu [private]

Definiert in Zeile 353 der Datei MutFrame.h.

Wird benutzt von MutFrame::MutFrame(), MutFrame::SetFileMenu() und MutFrame::~MutFrame().

int gs_nFrames = 0

Definiert in Zeile 68 der Datei MutChild.cpp.

wxHtmlHelpController* HelpController = (wxHtmlHelpController *) NULL

Definiert in Zeile 228 der Datei MutApp.cpp.

Wird benutzt von MutConfigDialog::CmHelp(), IMPLEMENT_APP(), MutApp::OnExit() und MutApp::ShowHelp().

wxBitmap MutToolBarBitmaps::IndevsPause [static]

Definiert in Zeile 56 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

wxBitmap MutToolBarBitmaps::IndevsPlay [static]

Definiert in Zeile 54 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

wxBitmap MutToolBarBitmaps::IndevsStop [static]

Definiert in Zeile 55 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

bool MutToolBarBitmaps::initialized = false [static, private]

Definiert in Zeile 36 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

wxWindow* MutFrame::keywindows[MAX_BOX] [private]

Definiert in Zeile 374 der Datei MutFrame.h.

wxBitmap MutToolBarBitmaps::LogicActivate [static]

Definiert in Zeile 44 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

bool LogicOn

Definiert in Zeile 316 der Datei MutFrame.cpp.

bool LogicOn = false

Definiert in Zeile 316 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CeActivate(), MutFrame::CeExecute(), MutFrame::CeInDevPause(), MutFrame::CeInDevPlay(), MutFrame::CeStop(), MutFrame::CmDoActivate(), MutFrame::CmInDevPlay(), MutFrame::CmInDevStop(), MutFrame::CmPanic(), MutFrame::CmRoutes(), MutFrame::CmToggleCAW(), MutFrame::CmToggleOWM(), MutFrame::DoStop(), MutRouteWnd::OnDraw(), MutFrame::StopInDev() und MutFrame::ToggleTextBox().

wxBitmap MutToolBarBitmaps::LogicPanic [static]

Definiert in Zeile 46 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

wxBitmap MutToolBarBitmaps::LogicStop [static]

Definiert in Zeile 45 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

const wxChar MutPanelNameStr[]

wxBitmap MutToolBarBitmaps::New [static]

Definiert in Zeile 39 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

wxBitmap MutToolBarBitmaps::Open [static]

Definiert in Zeile 40 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

bool OWM

Definiert in Zeile 314 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CeToggleOWM(), MutFrame::CmDoActivate() und MutFrame::CmToggleOWM().

bool OWM = false

Definiert in Zeile 314 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CeToggleOWM(), MutFrame::CmDoActivate() und MutFrame::CmToggleOWM().

wxBitmap MutToolBarBitmaps::Paste [static]

Definiert in Zeile 49 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

wxBitmap MutToolBarBitmaps::Print [static]

Definiert in Zeile 43 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

int pubTaste

Definiert in Zeile 68 der Datei MutLogicWnd.cpp.

Wird benutzt von MutLogicWnd::CmTaste() und MutLogicWnd::OnChar().

wxBitmap MutToolBarBitmaps::Redo [static]

Definiert in Zeile 51 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

wxBitmap MutToolBarBitmaps::RouteLoad [static]

Definiert in Zeile 52 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

wxBitmap MutToolBarBitmaps::RouteSave [static]

Definiert in Zeile 53 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

wxBitmap MutToolBarBitmaps::Save [static]

Definiert in Zeile 41 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

wxBitmap MutToolBarBitmaps::SaveAs [static]

Definiert in Zeile 42 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

bool SaveEditor = true

Definiert in Zeile 312 der Datei MutFrame.cpp.

Wird benutzt von MutConfigDialog::MutConfigDialog(), MutApp::RestoreState() und MutApp::SaveState().

bool SaveEditor

Definiert in Zeile 312 der Datei MutFrame.cpp.

Wird benutzt von MutConfigDialog::MutConfigDialog(), MutApp::RestoreState() und MutApp::SaveState().

wxSize subSize = wxDefaultSize

Definiert in Zeile 1464 der Datei MutFrame.cpp.

wxString TextBoxTitle[]

Initialisierung:

        { _("Current keys"), _("Tone system"), _("Actions") }

Definiert in Zeile 52 der Datei MutTextBox.cpp.

bool TextBoxWanted[MAX_BOX][3]

Initialisierung:

 {
                                         { false, false, false },
                                         { false, false, false },
                                         { false, false, false },
                                         { false, false, false },
                                         { false, false, false },
                                         { false, false, false },
                                         { false, false, false },
                                         { false, false, false },
                                         { false, false, false },
                                         { false, false, false },
                                         { false, false, false },
                                         { false, false, false },
                                         { false, false, false },
                                         { false, false, false },
                                         { false, false, false },
                                         { false, false, false }
                                 }

Definiert in Zeile 326 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CeToggleAct(), MutFrame::CeToggleKey(), MutFrame::CeToggleTS(), MutFrame::CmDoActivate(), MutTextBox::OnClose(), MutApp::RestoreState(), MutApp::SaveState() und MutFrame::ToggleTextBox().

bool TextBoxWanted[][3]

Definiert in Zeile 326 der Datei MutFrame.cpp.

Wird benutzt von MutFrame::CeToggleAct(), MutFrame::CeToggleKey(), MutFrame::CeToggleTS(), MutFrame::CmDoActivate(), MutTextBox::OnClose(), MutApp::RestoreState(), MutApp::SaveState() und MutFrame::ToggleTextBox().

MutFrame* theFrame = 0

Definiert in Zeile 308 der Datei MutFrame.cpp.

wxWindow* MutFrame::tswindows[MAX_BOX] [private]

Definiert in Zeile 375 der Datei MutFrame.h.

wxBitmap MutToolBarBitmaps::Undo [static]

Definiert in Zeile 50 der Datei MutBitmaps.h.

Wird benutzt von MutToolBarBitmaps::Init().

bool UseColorBars = true

Definiert in Zeile 313 der Datei MutFrame.cpp.

Wird benutzt von MutConfigDialog::MutConfigDialog(), MutApp::RestoreState(), MutApp::SaveState() und MutLogicWnd::UpDate().

bool UseColorBars

Definiert in Zeile 313 der Datei MutFrame.cpp.

Wird benutzt von MutConfigDialog::MutConfigDialog(), MutApp::RestoreState(), MutApp::SaveState() und MutLogicWnd::UpDate().

bool UseColorBars

Definiert in Zeile 313 der Datei MutFrame.cpp.

ArrayOfWinAttr WinAttrs[WK_NULL]

Initialisierung:

 {
                                           ArrayOfWinAttr(), ArrayOfWinAttr(), ArrayOfWinAttr(),
                                           ArrayOfWinAttr(), ArrayOfWinAttr(), ArrayOfWinAttr()
                                   }

Definiert in Zeile 72 der Datei MutChild.cpp.

Wird benutzt von MutFrame::CloseAll(), MutFrame::CmDoActivate(), MutFrame::CmToggleCAW(), MutFrame::CmToggleOWM(), MutChild::deleteFromWinAttrs(), Get(), GetWinAttr(), NumberOfOpen(), MutFrame::RaiseLogic(), MutFrame::UpdateUI() und MutLogicWnd::~MutLogicWnd().

char WinName[5][12] = { "KEYWIN", "TONSYSTWIN", "ACTIONWIN", "LOGICWIN", "ROUTEWIN" }

Definiert in Zeile 344 der Datei MutFrame.cpp.

int WSize[4][3]

Initialisierung:

        { { 640, 530, 252},
          { 800, 646, 328},
          {1024, 826, 425},
          {1280, 994, 620} }

Definiert in Zeile 1466 der Datei MutFrame.cpp.

MutApp::CmSetup MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerCMD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD MutApp::PassEventToDocManagerUPD wxID_FILE9

Definiert in Zeile 714 der Datei MutApp.cpp.

Klassen

Namensbereiche

Makrodefinitionen

Aufzählungen

Funktionen

Variablen

Ausführliche Beschreibung

Makro-Dokumentation

Dokumentation der Aufzählungstypen

Dokumentation der Funktionen

Variablen-Dokumentation