/*#include <guitar/mainfrm.hpp>
#include <guitar/viewwnd.hpp>
#include <guitar/fretviewwnd.hpp>
#include <guitar/guitar.hpp>
#include <guitar/registry.hpp>
#include <guitar/chorddlg.hpp>
#include <guitar/ChordBuilderDialog.hpp>
#include <guitar/rangedlg.hpp>
#include <guitar/SettingsDlg.hpp>
#include <guitar/ScaleDlg.hpp>
#include <guitar/globaldefs.hpp>
#include <guitar/DragQueryFile.hpp>
#include <guitar/MIDIHelper.hpp>
#include <guitar/splash.hpp>
#include <guitar/MIDIDialog.hpp>
#include <guitar/LicenseDialog.hpp>
#include <guitar/Registration.hpp>
#include <guitar/BrowserHelper.hpp>
#include <guitar/MessageBox.hpp>
#include <guitar/CBCommands.hpp>
#include <music/scale.hpp>
*/
#include <statbar/statbarx.hpp>
#include <common/opendlg.hpp>
#include <common/purebmp.hpp>
#include <common/resbmp.hpp>
#include <common/profile.hpp>
#include <common/versioninfo.hpp>
#include <common/process.hpp>
#include <common/crsctrl.hpp>
#include <common/shellapi.hpp>
#include <printman/printman.hpp>

#include <drums/mainfrm.hpp>
#include <drums/drums.hpp>
#include <drums/viewwnd.hpp>


MainFrame::MainFrame(void)
{
  mPaintHandler.setCallback(this,&MainFrame::paintHandler);
	mCloseHandler.setCallback(this,&MainFrame::closeHandler);
	mQueryEndSessionHandler.setCallback(this,&MainFrame::queryEndSessionHandler);
	mDestroyHandler.setCallback(this,&MainFrame::destroyHandler);
	mCommandHandler.setCallback(this,&MainFrame::commandHandler);
	mKeyDownHandler.setCallback(this,&MainFrame::keyDownHandler);
	mSizeHandler.setCallback(this,&MainFrame::sizeHandler);
	mCreateHandler.setCallback(this,&MainFrame::createHandler);
//	mGUIFretboardHandler.setCallback(this,&MainFrame::guiFretboardHandler);
//	mDropFilesHandler.setCallback(this,&MainFrame::dropFilesHandler);
	insertHandlers();
}

MainFrame::~MainFrame()
{
  removeHandlers();
}

void MainFrame::insertHandlers(void)
{
	FrameWindow::insertHandler(MainFrame::DestroyHandler,&mDestroyHandler);
	FrameWindow::insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
	FrameWindow::insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
	FrameWindow::insertHandler(VectorHandler::SizeHandler,&mSizeHandler);
	FrameWindow::insertHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
	FrameWindow::insertHandler(VectorHandler::CloseHandler,&mCloseHandler);
	FrameWindow::insertHandler(VectorHandler::QueryEndSessionHandler,&mQueryEndSessionHandler);
	FrameWindow::insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
//	FrameWindow::insertHandler(VectorHandler::DropFilesHandler,&mDropFilesHandler);
}

void MainFrame::removeHandlers(void)
{
	FrameWindow::removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
	FrameWindow::removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
	FrameWindow::removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
	FrameWindow::removeHandler(VectorHandler::SizeHandler,&mSizeHandler);
	FrameWindow::removeHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
	FrameWindow::removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
	FrameWindow::removeHandler(VectorHandler::CloseHandler,&mCloseHandler);
	FrameWindow::removeHandler(VectorHandler::QueryEndSessionHandler,&mQueryEndSessionHandler);
//	FrameWindow::removeHandler(VectorHandler::DropFilesHandler,&mDropFilesHandler);
}

CallbackData::ReturnType MainFrame::commandHandler(CallbackData &someCallbackData)
{
  switch(LOWORD(someCallbackData.wParam()))
	{
		case MENU_EDIT_CUT :
//		  handleCut();
			return false;
		case MENU_EDIT_COPY :
//		  handleCopy();
			return false;
		case MENU_EDIT_PASTE :
//		  handlePaste();
			return false;
	}
	switch(someCallbackData.wParam())
	{
		case MENU_FILE_EXIT :
		  handleFileExit();
		  break;
    case MENU_FILE_NEW :
		  handleFileNew();
		  break;
		case MENU_FILE_OPEN :
			handleFileOpen();
		  break;


/*
	  case MENU_FILE_PRINT :
		  handleFilePrint();
			break;
		case MENU_FILE_IMPORT :
			handleFileImport();
			break;
		case MENU_FILE_MIDI_IMPORT :
			handleMIDIImport();
			break;
		case MENU_FILE_CLOSE :
		  handleFileClose();
			break;
		case MENU_FILE_SAVE :
		  handleFileSave();
		  break;
		case MENU_FILE_SAVEAS :
		  handleFileSaveAs();
		  break;
		case MENU_VIEW_FRETBOARD :
		  handleViewFretboard();
			break;
		case MENU_TABLATURE_PLAY :
		  handlePlayTablature();
			break;
		case MENU_TABLATURE_PLAYTOEND :
		  handlePlayTablatureFromCurrent();
			break;
		case MENU_TABLATURE_PLAYREPEATED :
		  handlePlayRepeated();
			break;
		case MENU_TABLATURE_PLAYRANGE :
		  handlePlayRange();
		  break;
		case MENU_TABLATURE_PLAYRANGE_REPEATED :
		  handlePlayRangeRepeated();
			break;
		case MENU_TABLATURE_STOP :
		  handleStopPlay();
			break;
		case MENU_TABLATURE_ENTRYPROPS :
		  handleEntryProperties();
			break;
    case MENU_TABLATURE_SETENDRANGE :
		  handleSetEndRange();
			break;
    case MENU_TABLATURE_SETSTARTRANGE :
		  handleSetStartRange();
		  break;
		case MENU_EDIT_RANGES :
		  handleEditRanges();
			break;
	  case MENU_OPTIONS_INCREASETEMPO :
		  handleIncreaseTempo();
			break;
		case MENU_OPTIONS_DECREASETEMPO :
		  handleDecreaseTempo();
			break;
		case MENU_OPTIONS_SETTINGS :
		  handleSettings();
			break;
		case MENU_CHORDS_LOOKUP :
		  handleChordLookup();
		  break;
		case MENU_CHORDS_ENTER :
			handleChordEnter();
			break;
		case MENU_FRETBOARD_CLEAR :
		  handleClearFretboard();
			break;
		case MENU_FRETBOARD_SHOWALLPOSITIONS :
		  handleShowAllPositions();
			break;
		case MENU_SCALES_SHOW :
		  handleShowScales();
			break;
		case MENU_EDIT_CUT :
		  handleCut();
		  break;
		case MENU_EDIT_COPY :
		  handleCopy();
		  break;
		case MENU_EDIT_PASTE :
		  handlePaste();
		  break;
    case MENU_HELP_APPLY_LICENSE :
		  handleHelpApplyLicense();
			break;
		case MENU_HELP_ABOUT :
		  handleHelpAbout();
			break;
		case MENU_HELP_INDEX :
		  handleHelpIndex();
			break;
	  case IDM_CASCADE :
		  cascade();
			break;
		case IDM_TILE :
		  tile();
			break;
		case IDM_ARRANGE :
		  arrange();
			break;
		case IDM_CLOSEALL :
		  closeAll();
			break;
		case IDM_MINIMIZEALL :
		  minimizeAll();
			break;
		case IDM_RESTOREALL :
		  restoreAll();
			break;
*/

		default :
      break;
	}
//	if(someCallbackData.wParam()>=StartDynamicID)handleOpenProject(someCallbackData);
	return (CallbackData::ReturnType)FALSE;
//  return FALSE;
}

CallbackData::ReturnType MainFrame::keyDownHandler(CallbackData &/*someCallbackData*/)
{
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainFrame::paintHandler(CallbackData &/*someCallbackData*/)
{
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainFrame::createHandler(CallbackData &callbackData)
{
  ::DragAcceptFiles(*this,true);
//  insert(*::new FretViewWindow());
//	operator[](size()-1).createWindow(*this,String(STRING_FRETVIEWWINDOWCLASSNAME),"Fretboard","fretMenu","APP_ICON");
  createControls(callbackData);
	Control desktop(::GetDesktopWindow(),0,false);
	setWindowPos(desktop.width()>InitialWidth?InitialWidth:desktop.width(),desktop.height()>InitialHeight?InitialHeight:desktop.height());
  show(SW_SHOW);
	update();
	mStatusControl->setText("Ready.");
//  updateHistory();
//	if(!validateLicense())postMessage(*this,WM_CLOSE,0,0L);
  return (CallbackData::ReturnType)FALSE;

}

CallbackData::ReturnType MainFrame::dropFilesHandler(CallbackData &someCallbackData)
{
/*  Block<String> strFileNames;
	String strPathFileName;
	String strPathFileProject;
	String strExtension;
	File inFile;

  GlobalDefs::outDebug("MainFrame::dropFileHandler");
	DragQueryFile::getFileNames((HDROP)someCallbackData.wParam(),strFileNames);
	for(int index=0;index<strFileNames.size();index++)
	{
	  strPathFileName=strFileNames[index];
		strExtension=Profile::getExtension(strPathFileName);
		strExtension.lower();
		if(strExtension==String(STRING_TABEXTENSION))
		{
		  strPathFileProject=Tablature::getPathFileProject(strPathFileName);
			if(!inFile.open(strPathFileProject))
			{
			  createProjectView(strFileNames[index]);
			}
			else 
			{
			  inFile.close();
				openProjectView(strPathFileProject);
			}
		}
		else if(strExtension==String(STRING_PRJEXTENSION))
		{
		  openProjectView(strPathFileName);
		}
		else if(strExtension==String(STRING_MIDIEXTENSION))
		{
      String strPathTabFileName;
			MIDIHelper midiHelper;
			CursorControl cursorControl;
      MIDIDialog midiDialog;
      License license;
			int selectedTrack;

			Registration::getInstance().getLicense(license);
			if(!license.allowFeature(License::MIDIFeature))
			{
        MessageBox::messageBox(*this,strPathFileName,"This feature is disabled in this version.",MB_ICONSTOP);
        return false;
			}
			if(!midiDialog.perform(*this,strPathFileName,selectedTrack))continue;
			strPathTabFileName=Profile::removeExtension(strPathFileName)+String("TRK")+String().fromInt(selectedTrack+1)+String(".tab");
			if(!midiHelper.import(strPathFileName,strPathTabFileName,selectedTrack))
			{
				MessageBox::messageBox(*this,strPathFileName,"Error importing file.",MB_ICONSTOP);
				return false;
			}
			cursorControl.waitCursor(true);
		  createProjectView(strPathTabFileName);
			cursorControl.waitCursor(false);
		}
		else return false;
	}
*/
  return false;
}

CallbackData::ReturnType MainFrame::queryEndSessionHandler(CallbackData &someCallbackData)
{
  if(getClient().hasChildren())return (CallbackData::ReturnType)FALSE;
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainFrame::closeHandler(CallbackData &someCallbackData)
{
	destroy();
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainFrame::destroyHandler(CallbackData &/*someCallbackData*/)
{
  removeHandlers();
  ::PostQuitMessage(0);
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainFrame::sizeHandler(CallbackData &someCallbackData)
{
  Rect statusRect;
	Rect toolRect;
	Rect cRect;

  mToolBar.windowRect(toolRect);
	mStatusControl->windowRect(statusRect);
	cRect.right(someCallbackData.loWord());
	cRect.bottom(someCallbackData.hiWord());
	getClient().moveWindow(0,toolRect.bottom()-toolRect.top(),cRect.right(),cRect.bottom()-((statusRect.bottom()-statusRect.top())+(toolRect.bottom()-toolRect.top())));
  return (CallbackData::ReturnType)FALSE;
}

void MainFrame::createControls(const CallbackData &callbackData)
{
  Rect statusRect;
	Rect toolRect;
	Rect cRect;

  createToolBar();
  mStatusControl=::new StatusBarEx(*this,StatusBarID);
	mStatusControl.disposition(PointerDisposition::Delete);
  mToolBar.windowRect(toolRect);
	mStatusControl->windowRect(statusRect);
	cRect.right(callbackData.loWord());
	cRect.bottom(callbackData.hiWord());
	getClient().moveWindow(0,toolRect.bottom()-toolRect.top(),cRect.right(),cRect.bottom()-((statusRect.bottom()-statusRect.top())+(toolRect.bottom()-toolRect.top())));
}

void MainFrame::createToolBar(void)
{
  Block<AddBitmap> addBitmaps;

  mToolBar.create(*this,ToolBarID);
	addBitmaps.insert(&AddBitmap(0,HINST_COMMCTRL));
	if(!mToolBar.addBitmaps(addBitmaps))return;
	mToolBar.addButton(ToolBarButton(STD_FILEOPEN,MENU_FILE_OPEN,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar.addButton(ToolBarButton(STD_FILENEW,MENU_FILE_NEW,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
//	mToolBar.addButton(ToolBarButton(STD_FILESAVE,MENU_FILE_SAVE,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
//	mToolBar.addButton(ToolBarButton(STD_PRINT,MENU_FILE_PRINT,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar.addButton(ToolBarButton(STD_CUT,-1,ToolBarButton::StateIndeterminate,ToolBarButton::StyleButton));
	mToolBar.addButton(ToolBarButton(STD_COPY,-1,ToolBarButton::StateIndeterminate,ToolBarButton::StyleButton));
	mToolBar.addButton(ToolBarButton(STD_PASTE,-1,ToolBarButton::StateIndeterminate,ToolBarButton::StyleButton));
	mToolBar.addButton(ToolBarButton(STD_FIND,-1,ToolBarButton::StateIndeterminate,ToolBarButton::StyleButton));
}

/*
void MainFrame::openProjectView(const String &strPathProjectFile)
{
  SmartPointer<MDIWindow> mdiWindow;
	ViewWindow *pViewWindow;

	if(strPathProjectFile.isNull())return;
	if(isActive(mdiWindow,strPathProjectFile))
	{
	  mdiWindow->top();
		return;
	}
	insert(*(pViewWindow=::new ViewWindow));
	operator[](size()-1).createWindow(*this,String(STRING_TABVIEWWINDOWCLASSNAME),"Tablature","viewMenu","APP_ICON");
	pViewWindow->setStatusControlRef(mStatusControl);
	if(!pViewWindow->openProject(strPathProjectFile))
	{
	  pViewWindow->close();
		return;
	}
	else pViewWindow->setFretboardHandler(CallbackPointer(&mGUIFretboardHandler));
  updateHistory(strPathProjectFile);
}
*/

/*
void MainFrame::createProjectView(const String &strPathTabFile)
{
  SmartPointer<MDIWindow> mdiWindow;
	ViewWindow *pViewWindow;

	if(strPathTabFile.isNull())return;
	insert(*(pViewWindow=::new ViewWindow));
	operator[](size()-1).createWindow(*this,String(STRING_TABVIEWWINDOWCLASSNAME),"Tablature","viewMenu","APP_ICON");
	pViewWindow->setStatusControlRef(mStatusControl);
	if(!pViewWindow->createProject(strPathTabFile))
	{
	  pViewWindow->close();
	}
	else 
	{
    pViewWindow->setFretboardHandler(CallbackPointer(&mGUIFretboardHandler));
    updateHistory(pViewWindow->getPathFileProject());
	}
}
*/

/*
void MainFrame::createProjectView(void)
{
  SmartPointer<MDIWindow> mdiWindow;
	ViewWindow *pViewWindow;

	insert(*(pViewWindow=::new ViewWindow));
	operator[](size()-1).createWindow(*this,String(STRING_TABVIEWWINDOWCLASSNAME),"Tablature","viewMenu","APP_ICON");
  pViewWindow->setStatusControlRef(mStatusControl);
	if(!pViewWindow->createProject())
	{
	  pViewWindow->close();
	}
	else pViewWindow->setFretboardHandler(CallbackPointer(&mGUIFretboardHandler));
  mStatusControl->setText(String(STRING_EDITHINT));
}
*/

/*
bool MainFrame::isActive(SmartPointer<MDIWindow> &viewWindow,const String &strPathFileProject)
{
  SmartPointer<MDIWindow> mdiWindow;
	Array<SmartPointer<MDIWindow> > mdiWindows;
	String strTitle;

	if(!getDocuments(mdiWindows))return false;
	for(int index=0;index<mdiWindows.size();index++)
	{
	  mdiWindow=mdiWindows[index];
	  if(mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME))
		{
		  ViewWindow &view=(ViewWindow&)*mdiWindow;
			if(view.getTitle()==strPathFileProject)
			{
			  viewWindow=mdiWindow;
				return true;
			}
	  }
	}
  return false;
}
*/

// menu handlers

/*
void MainFrame::handleEntryProperties(void)
{
  SmartPointer<MDIWindow> mdiWindow;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))return;
	((ViewWindow&)*mdiWindow).modifyProperties();
	return;
}
*/

/*
void MainFrame::handleFilePrint(void)
{
	Printer printer;
  PrintManager printManager;
  SmartPointer<MDIWindow> mdiWindow;
	String strCaption;
	PureBitmap pureBitmap;
	Rect windowRect;

  if(!printManager.choosePrinter(*this,printer))return;
	if(!getActive(mdiWindow))return;
	mdiWindow->windowText(strCaption);
  mdiWindow->windowRect(windowRect);
  pureBitmap.screenBitmap(windowRect);
	if(!printManager.openPrinter(printer,*this,strCaption))
	{
	  ::MessageBeep(0);
		MessageBox::messageBox(*this,printer.printerName(),"Error opening printer, check the printer and try again.",MB_ICONSTOP);
	  return;
	}
	if(!printManager.printBitmap(pureBitmap,true,(WORD)300))
	{
	  ::MessageBeep(0);
		MessageBox::messageBox(*this,printer.printerName(),"Error sending document to printer, check the printer and try again.",MB_ICONSTOP);
	}
  printManager.closePrinter();
}
*/

void MainFrame::handleFileNew(void)
{
  SmartPointer<MDIWindow> mdiWindow;
	ViewWindow *pViewWindow;

//	if(strPathTabFile.isNull())return;
	insert(*(pViewWindow=::new ViewWindow));
	operator[](size()-1).createWindow(*this,String(STRING_DRUMVIEWWINDOWCLASSNAME),"Drums","viewMenu","APP_ICON");
	pViewWindow->show(SW_SHOW);
	pViewWindow->top();

//	pViewWindow->setStatusControlRef(mStatusControl);
//	if(!pViewWindow->createProject(strPathTabFile))
//	{
//	  pViewWindow->close();
//	}
//	else 
//	{
 //   pViewWindow->setFretboardHandler(CallbackPointer(&mGUIFretboardHandler));
 //   updateHistory(pViewWindow->getPathFileProject());
//	}
}

void MainFrame::handleFileOpen(void)
{
}

void MainFrame::handleFileExit(void)
{
  postMessage(*this,WM_CLOSE,0,0L);
}

/*
void MainFrame::handleFileImport(void)
{
  OpenDialog openDialog;
  String strPathTabFile;

  openDialog.creationFlags(OpenDialog::ALLOWMULTISELECT);
	if(!openDialog.getOpenFileName(*this,"*.tab","Open Tab","*.tab",strPathTabFile))return;
  for(int index=0;index<openDialog.size();index++)
	{
	  strPathTabFile=openDialog[index];
		createProjectView(strPathTabFile);
	}
}
*/


/*
void MainFrame::handleOpenProject(CallbackData &someCallbackData)
{
	PureMenu fileMenu;
	String menuItemString;

	getFrameMenu().getSubMenu(0,fileMenu);
	menuItemString=fileMenu.menuItemString(someCallbackData.wParam(),PureMenu::ByCommand);
	if(menuItemString.isNull())return;
	menuItemString=menuItemString.betweenString(')',0);
	menuItemString.trimLeft();
	handleOpenProject(menuItemString);
}
*/

/*
void MainFrame::handleOpenProject(void)
{
  OpenDialog openDialog;
  String strPathFileName;

  openDialog.creationFlags(OpenDialog::ALLOWMULTISELECT);
	if(!openDialog.getOpenFileName(*this,String(STRING_PRJALLEXTENSION),"Open Project",String(STRING_PRJALLEXTENSION),strPathFileName))return;
  for(int index=0;index<openDialog.size();index++)
	{
	  strPathFileName=openDialog[index];
  	handleOpenProject(strPathFileName);
	}
}
*/

/*
void MainFrame::handleOpenProject(const String &strPathFileProject)
{
	openProjectView(strPathFileProject);
}
*/

/*
void MainFrame::handleFileClose(void)
{
  SmartPointer<MDIWindow> mdiWindow;
	if(!getActive(mdiWindow))return;
	mdiWindow->close();
}
*/

/*
void MainFrame::handleFileSave(void)
{
  SmartPointer<MDIWindow> mdiWindow;
	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))return;
	ViewWindow &viewWindow=(ViewWindow&)*mdiWindow;
	String strTitle=viewWindow.getTitle();
	if(viewWindow.getTitle()==String(STRING_NOTITLE)){handleFileSaveAs();return;}
	viewWindow.saveProject();
	return; 
}
*/

/*
void MainFrame::handleFileSaveAs(void)
{
  SmartPointer<MDIWindow> mdiWindow;
  OpenDialog openDialog;
	String strPathFileProject;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))return;
	if(!openDialog.getSaveFileName(*this,"Project Files","Project Save",String(STRING_PRJALLEXTENSION),strPathFileProject))return;
	if(!strPathFileProject.strstr(String(STRING_PRJEXTENSION)))strPathFileProject+=String(STRING_PRJEXTENSION);
	((ViewWindow&)*mdiWindow).saveProject(strPathFileProject);
  updateHistory(strPathFileProject);
}
*/

/*
void MainFrame::handleChordLookup()
{
  ChordDialog chordDialog;
	chordDialog.perform(*this,CallbackPointer(&mGUIFretboardHandler));
}
*/

/*
void MainFrame::handleChordEnter()
{
  ChordBuilderDialog chordBuilderDialog;
	chordBuilderDialog.perform(*this,CallbackPointer(&mGUIFretboardHandler));
}
*/

/*
void MainFrame::handlePlayTablature(void)
{
  SmartPointer<MDIWindow> mdiWindow;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))return;
	((ViewWindow&)*mdiWindow).play();
	return;
}
*/

/*
void MainFrame::handlePlayTablatureFromCurrent()
{
  SmartPointer<MDIWindow> mdiWindow;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))return;
	((ViewWindow&)*mdiWindow).playFromCurrent();
	return;
}
*/

/*
void MainFrame::handleStopPlay(void)
{
  SmartPointer<MDIWindow> mdiWindow;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))return;
	((ViewWindow&)*mdiWindow).stopPlay();
	return;
}
*/

/*
void MainFrame::handlePlayRepeated()
{
  SmartPointer<MDIWindow> mdiWindow;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))return;
	((ViewWindow&)*mdiWindow).playRepeated();
	return;
}
*/

/*
void MainFrame::handlePlayRange(void)
{
  SmartPointer<MDIWindow> mdiWindow;
  RangeDialog rangeDialog;
	TabRanges ranges;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))return;
	ViewWindow &viewWindow=((ViewWindow&)*mdiWindow);
	viewWindow.getTabRanges(ranges);
	if(!rangeDialog.perform(*this,ranges,viewWindow.getNumTabEntries(),true))return;  
	viewWindow.playRange(rangeDialog.getSelection());
}
*/

/*
void MainFrame::handlePlayRangeRepeated(void)
{
  SmartPointer<MDIWindow> mdiWindow;
	ViewWindow *pViewWindow;
  RangeDialog rangeDialog;
	TabRanges ranges;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))return;
	ViewWindow &viewWindow=((ViewWindow&)*mdiWindow);
	viewWindow.getTabRanges(ranges);
	if(!rangeDialog.perform(*this,ranges,viewWindow.getNumTabEntries(),true))return; 
	viewWindow.playRangeRepeated(rangeDialog.getSelection());
}
*/

/*
void MainFrame::handleIncreaseTempo(void)
{
  SmartPointer<MDIWindow> mdiWindow;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))return;
	((ViewWindow&)*mdiWindow).increaseTempo();
	return;
}
*/

/*
void MainFrame::handleDecreaseTempo(void)
{
  SmartPointer<MDIWindow> mdiWindow;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))return;
	((ViewWindow&)*mdiWindow).decreaseTempo();
	return;
}
*/

/*
void MainFrame::handleCut(void)
{
  SmartPointer<MDIWindow> mdiWindow;

	if(!getActive(mdiWindow))return;
	if((mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))((ViewWindow&)*mdiWindow).cut();
	else if((mdiWindow->className()==String(STRING_FRETVIEWWINDOWCLASSNAME)))((FretViewWindow&)*mdiWindow).cut();
	return;
}
*/

/*
void MainFrame::handleCopy(void)
{
  SmartPointer<MDIWindow> mdiWindow;

	if(!getActive(mdiWindow))return;
	if((mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))((ViewWindow&)*mdiWindow).copy();
	else if((mdiWindow->className()==String(STRING_FRETVIEWWINDOWCLASSNAME)))((FretViewWindow&)*mdiWindow).copy();
	return;
}
*/

/*
void MainFrame::handlePaste(void)
{
  SmartPointer<MDIWindow> mdiWindow;

	if(!getActive(mdiWindow))return;
	if((mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))((ViewWindow&)*mdiWindow).paste();
	else if((mdiWindow->className()==String(STRING_FRETVIEWWINDOWCLASSNAME)))((FretViewWindow&)*mdiWindow).paste();
	return;
}
*/

/*
void MainFrame::handleSettings(void)
{
  SettingsDialog settingsDialog;
	settingsDialog.perform(*this);
}
*/

/*
void MainFrame::handleSetStartRange(void)
{
  SmartPointer<MDIWindow> mdiWindow;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))return;
	((ViewWindow&)*mdiWindow).setStartRange();
	return;
}
*/

/*
void MainFrame::handleSetEndRange(void)
{
  SmartPointer<MDIWindow> mdiWindow;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))return;
	((ViewWindow&)*mdiWindow).setEndRange();
	return;
}
*/

/*
void MainFrame::handleViewFretboard(void)
{
  SmartPointer<MDIWindow> fretWindow;
  if(!getDocumentClass(String(STRING_FRETVIEWWINDOWCLASSNAME),fretWindow))
	{
    insert(*::new FretViewWindow());
	  operator[](size()-1).createWindow(*this,String(STRING_FRETVIEWWINDOWCLASSNAME),"Fretboard","fretMenu","APP_ICON");
		getDocumentClass(String(STRING_FRETVIEWWINDOWCLASSNAME),fretWindow);
	}
	if(fretWindow->isIconic())fretWindow->show(SW_RESTORE);
  else fretWindow->top();
}
*/

/*
void MainFrame::handleShowAllPositions(void)
{
  SmartPointer<MDIWindow> mdiWindow;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_FRETVIEWWINDOWCLASSNAME)))
	{
    handleViewFretboard();
		return;
	}
	FretViewWindow &fretViewWindow=((FretViewWindow&)*mdiWindow);
	fretViewWindow.showAllPositions();
}
*/

/*
void MainFrame::handleClearFretboard(void)
{
  SmartPointer<MDIWindow> mdiWindow;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_FRETVIEWWINDOWCLASSNAME)))
	{
    handleViewFretboard();
		getActive(mdiWindow);
	}
	FretViewWindow &fretViewWindow=((FretViewWindow&)*mdiWindow);
	fretViewWindow.clearNotes();
}
*/

/*
void MainFrame::handleEditRanges(void)
{
  SmartPointer<MDIWindow> mdiWindow;
  RangeDialog rangeDialog;
	TabRanges ranges;

	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_TABVIEWWINDOWCLASSNAME)))return;
	ViewWindow &viewWindow=((ViewWindow&)*mdiWindow);
	viewWindow.getTabRanges(ranges);
	if(!rangeDialog.perform(*this,ranges,viewWindow.getNumTabEntries()))return;
  viewWindow.setTabRanges(rangeDialog.getTabRanges());
}
*/

/*
void MainFrame::handleShowScales()
{
  ScaleDialog scaleDialog;
	scaleDialog.perform(*this,CallbackPointer(&mGUIFretboardHandler));
}
*/

/*
void MainFrame::handleHelpAbout()
{
	VersionInfo versionInfo;
  SplashScreen splash("GUITAR","2002 - Diversified Software Solutions. \"http:\\www.guitartabpro.com\"",versionInfo.getProductNameString()+String(" ")+versionInfo.getProductVersion());
	splash.perform();
}
*/

/*
void MainFrame::handleHelpIndex(void)
{
  if(!BrowserHelper::launchBrowser(String(STRING_HOST)))
  {
    MessageBox::messageBox(*this,"Error","Unable to launch browser.");
	  return;
	}
}
*/

/*
void MainFrame::applyHistory(PureMenu &pureMenu)
{
  Registry registry;
	Block<String> nameList;
	PureMenu fileMenu;
  String strItem;

	registry.getHistory(nameList);
	if(!nameList.size())return;
	pureMenu.getSubMenu(0,fileMenu);
	fileMenu.appendSeparator();
	for(int itemIndex=0;itemIndex<nameList.size();itemIndex++)
	{
	  ::sprintf(strItem,"%d) %s",itemIndex+1,(char*)nameList[itemIndex]);
		fileMenu.appendMenu(StartDynamicID+itemIndex,strItem);
	}
}
*/

/*
void MainFrame::updateHistory(void)
{
  Registry registry;
  SmartPointer<MDIWindow> mdiWindow;
	Array<SmartPointer<MDIWindow> > mdiWindows;

	removeHistory(getFrameMenu());
	applyHistory(getFrameMenu());
	if(!getDocuments(mdiWindows))return;
	for(int index=0;index<mdiWindows.size();index++)
	{
	  mdiWindow=mdiWindows[index];
	  removeHistory(mdiWindow->getMenu());
		applyHistory(mdiWindow->getMenu());
	}
}
*/

/*
void MainFrame::updateHistory(const String &pathFileName)
{
  Registry registry;
  SmartPointer<MDIWindow> mdiWindow;
	Array<SmartPointer<MDIWindow> > mdiWindows;

	if(!registry.insertHistory(pathFileName))return;
	removeHistory(getFrameMenu());
	applyHistory(getFrameMenu());
	if(!getDocuments(mdiWindows))return;
	for(int index=0;index<mdiWindows.size();index++)
	{
	  mdiWindow=mdiWindows[index];
	  removeHistory(mdiWindow->getMenu());
		applyHistory(mdiWindow->getMenu());
	}
}
*/

/*
void MainFrame::removeHistory(PureMenu &pureMenu)
{
	Registry registry;
	UINT startID(StartDynamicID);
	Block<String> nameList;
	PureMenu fileMenu;

	registry.getHistory(nameList);
	if(!nameList.size())return;
	pureMenu.getSubMenu(0,fileMenu);
	for(int itemIndex=0;itemIndex<nameList.size();itemIndex++)fileMenu.removeMenu(startID++,PureMenu::ByCommand);
  int entries(fileMenu.size());
	if((int)PureMenu::TypeSeparator&(int)fileMenu.getMenuItemType(entries-1,PureMenu::ByPosition))fileMenu.removeMenu(entries-1,PureMenu::ByPosition);
}
*/

/*
bool MainFrame::validateLicense(void)const
{
  License license;
	Registration::getInstance().getLicense(license);
	if(!license.isValid()||license.isExpiring())
	{
    LicenseDialog licenseDialog;
		Registration::getInstance().removeLicense();
    if(!licenseDialog.perform((GUIWindow&)*this))return false;
	}
	return true;
}
*/

/*
void MainFrame::handleHelpApplyLicense(void)
{
  LicenseDialog licenseDialog;

  if(Registration::getInstance().hasLicense())
	{
	  License license;
		Registration::getInstance().getLicense(license);
		if(license.isValid()&&!license.isExpiring())
		{
		  MessageBox::messageBox(*this,"License","You already own a permanent license for this product.",MB_OK);
			return;
		}
	}
	licenseDialog.perform(*this,false);
}
*/

// ** virtuals

void MainFrame::preRegister(WNDCLASS &wndClass)
{
  wndClass.style|=CS_SAVEBITS|CS_OWNDC;
  wndClass.hbrBackground=(HBRUSH)::GetStockObject(GRAY_BRUSH);
}

bool MainFrame::preDestroy(MDIWindow &mdiWindow)
{
/*	LRESULT retCode;
  if(mdiWindow.className()==String(STRING_TABVIEWWINDOWCLASSNAME))
	{
	  ViewWindow &viewWindow=(ViewWindow&)mdiWindow;
		if(viewWindow.isDirty()&&IDYES==(retCode=MessageBox::messageBox(*this,String("[")+viewWindow.getTitle()+String("]"),"Save Changes",MB_YESNOCANCEL)))
		{
		  viewWindow.saveProject();
		}
		else if(IDCANCEL==retCode)return true;
	}
*/
	return false;
}

void MainFrame::mdiDestroy(MDIWindow &mdiWindow)
{
}

void MainFrame::mdiActivate(MDIWindow &mdiWindow)
{
/*  removeHistory(mdiWindow.getMenu());
	applyHistory(mdiWindow.getMenu());
  if(mdiWindow.className()==String(STRING_TABVIEWWINDOWCLASSNAME))
	{
	  ViewWindow &viewWindow=(ViewWindow&)mdiWindow;
	}
*/
}

void MainFrame::mdiDeactivate(MDIWindow &mdiWindow)
{
}