#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/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 <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 <printman/printman.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 :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_EDIT_CUT",GlobalDefs::Verbose);
		  handleCut();
			return false;
		case MENU_EDIT_COPY :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_EDIT_COPY",GlobalDefs::Verbose);
		  handleCopy();
			return false;
		case MENU_EDIT_PASTE :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_EDIT_PASTE",GlobalDefs::Verbose);
		  handlePaste();
			return false;
	}
	switch(someCallbackData.wParam())
	{
	  case MENU_FILE_PRINT :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_FILE_PRINT",GlobalDefs::Verbose);
		  handleFilePrint();
			break;
    case MENU_FILE_NEW :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_FILE_NEW",GlobalDefs::Verbose);
		  handleFileNew();
		  break;
		case MENU_FILE_OPEN :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_FILE_OPEN",GlobalDefs::Verbose);
			handleOpenProject();
		  break;
		case MENU_FILE_IMPORT :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_FILE_IMPORT",GlobalDefs::Verbose);
			handleFileImport();
			break;
		case MENU_FILE_MIDI_IMPORT :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_FILE_MIDI_IMPORT",GlobalDefs::Verbose);
			handleMIDIImport();
			break;
		case MENU_FILE_CLOSE :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_FILE_CLOSE",GlobalDefs::Verbose);
		  handleFileClose();
			break;
		case MENU_FILE_EXIT :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_FILE_EXIT",GlobalDefs::Verbose);
		  handleFileExit();
		  break;
		case MENU_FILE_SAVE :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_FILE_SAVE",GlobalDefs::Verbose);
		  handleFileSave();
		  break;
		case MENU_FILE_SAVEAS :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_FILE_SAVEAS",GlobalDefs::Verbose);
		  handleFileSaveAs();
		  break;
		case MENU_VIEW_FRETBOARD :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_VIEW_FRETBOARD",GlobalDefs::Verbose);
		  handleViewFretboard();
			break;
		case MENU_TABLATURE_PLAY :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_TABLATURE_PLAY",GlobalDefs::Verbose);
		  handlePlayTablature();
			break;
		case MENU_TABLATURE_PLAYTOEND :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_TABLATURE_PLAYTOEND",GlobalDefs::Verbose);
		  handlePlayTablatureFromCurrent();
			break;
		case MENU_TABLATURE_PLAYREPEATED :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_TABLATURE_PLAYREPEATED",GlobalDefs::Verbose);
		  handlePlayRepeated();
			break;
		case MENU_TABLATURE_PLAYRANGE :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_TABLATURE_PLAYRANGE",GlobalDefs::Verbose);
		  handlePlayRange();
		  break;
		case MENU_TABLATURE_PLAYRANGE_REPEATED :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_TABLATURE_PLAYRANGE_REPEATED",GlobalDefs::Verbose);
		  handlePlayRangeRepeated();
			break;
		case MENU_TABLATURE_STOP :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_TABLATURE_STOP",GlobalDefs::Verbose);
		  handleStopPlay();
			break;
		case MENU_TABLATURE_ENTRYPROPS :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_TABLATURE_ENTRYPROPS",GlobalDefs::Verbose);
		  handleEntryProperties();
			break;
    case MENU_TABLATURE_SETENDRANGE :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_TABLATURE_SETENDRANGE",GlobalDefs::Verbose);
		  handleSetEndRange();
			break;
    case MENU_TABLATURE_SETSTARTRANGE :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_TABLATURE_SETSTARTRANGE",GlobalDefs::Verbose);
		  handleSetStartRange();
		  break;
		case MENU_EDIT_RANGES :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_EDIT_RANGES",GlobalDefs::Verbose);
		  handleEditRanges();
			break;
	  case MENU_OPTIONS_INCREASETEMPO :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_OPTIONS_INCREASETEMPO",GlobalDefs::Verbose);
		  handleIncreaseTempo();
			break;
		case MENU_OPTIONS_DECREASETEMPO :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_OPTIONS_DECREASETEMPO",GlobalDefs::Verbose);
		  handleDecreaseTempo();
			break;
		case MENU_OPTIONS_SETTINGS :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_OPTIONS_SETTINGS",GlobalDefs::Verbose);
		  handleSettings();
			break;
		case MENU_CHORDS_LOOKUP :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_CHORDS_LOOKUP",GlobalDefs::Verbose);
		  handleChordLookup();
		  break;
		case MENU_FRETBOARD_CLEAR :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_FRETBOARD_CLEAR",GlobalDefs::Verbose);
		  handleClearFretboard();
			break;
		case MENU_FRETBOARD_SHOWALLPOSITIONS :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_FRETBOARD_SHOWALLPOSITIONS",GlobalDefs::Verbose);
		  handleShowAllPositions();
			break;
		case MENU_SCALES_SHOW :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_SCALES_SHOW",GlobalDefs::Verbose);
		  handleShowScales();
			break;
		case MENU_EDIT_CUT :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_EDIT_CUT",GlobalDefs::Verbose);
		  handleCut();
		  break;
		case MENU_EDIT_COPY :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_EDIT_COPY",GlobalDefs::Verbose);
		  handleCopy();
		  break;
		case MENU_EDIT_PASTE :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]MENU_EDIT_PASTE",GlobalDefs::Verbose);
		  handlePaste();
		  break;
    case MENU_HELP_APPLY_LICENSE :
		  handleHelpApplyLicense();
			break;
		case MENU_HELP_ABOUT :
		  handleHelpAbout();
			break;
		case MENU_HELP_INDEX :
		  handleHelpIndex();
			break;
	  case IDM_CASCADE :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]IDM_CASCADE",GlobalDefs::Verbose);
		  cascade();
			break;
		case IDM_TILE :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]IDM_TILE",GlobalDefs::Verbose);
		  tile();
			break;
		case IDM_ARRANGE :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]IDM_ARRANGE",GlobalDefs::Verbose);
		  arrange();
			break;
		case IDM_CLOSEALL :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]IDM_CLOSEALL",GlobalDefs::Verbose);
		  closeAll();
			break;
		case IDM_MINIMIZEALL :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]IDM_MINIMIZEALL",GlobalDefs::Verbose);
		  minimizeAll();
			break;
		case IDM_RESTOREALL :
		  GlobalDefs::outDebug("[MainFrame::commandHandler]IDM_RESTOREALL",GlobalDefs::Verbose);
		  restoreAll();
			break;
		default :
      break;
	}
	if(someCallbackData.wParam()>=StartDynamicID)handleOpenProject(someCallbackData);
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainFrame::keyDownHandler(CallbackData &/*someCallbackData*/)
{
  GlobalDefs::outDebug("[MainFrame::keyDownHandler]",GlobalDefs::Verbose);
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainFrame::paintHandler(CallbackData &/*someCallbackData*/)
{
  GlobalDefs::outDebug("[MainFrame::paintHandler]",GlobalDefs::Verbose);
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainFrame::createHandler(CallbackData &callbackData)
{
  ::DragAcceptFiles(*this,true);
  GlobalDefs::outDebug("[MainFrame::createHandler]",GlobalDefs::Verbose);
  insert(*::new FretViewWindow());
	operator[](size()-1).createWindow(*this,String(STRING_FRETVIEWWINDOWCLASSNAME),"Fretboard","fretMenu","APP_ICON");
  createControls(callbackData);
	setWindowPos(InitialWidth,InitialHeight);
  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)
{
  GlobalDefs::outDebug("[MainFrame::queryEndSessionHandler]",GlobalDefs::Verbose);
  if(getClient().hasChildren())return (CallbackData::ReturnType)FALSE;
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainFrame::closeHandler(CallbackData &someCallbackData)
{
  GlobalDefs::outDebug("[MainFrame::closeHandler]",GlobalDefs::Verbose);
	destroy();
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainFrame::destroyHandler(CallbackData &/*someCallbackData*/)
{
  GlobalDefs::outDebug("[MainFrame::destroyHandler]",GlobalDefs::Verbose);
  removeHandlers();
  ::PostQuitMessage(0);
	return (CallbackData::ReturnType)FALSE;
}

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

  GlobalDefs::outDebug("[MainFrame::sizeHandler]",GlobalDefs::Verbose);
  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;
}

CallbackData::ReturnType MainFrame::guiFretboardHandler(CallbackData &someCallbackData)
{
  SmartPointer<MDIWindow> mdiWindow;

  GlobalDefs::outDebug("[MainFrame::guiFretboardHandler]",GlobalDefs::Verbose);
  if(!getDocumentClass(String(STRING_FRETVIEWWINDOWCLASSNAME),mdiWindow))
	{
    insert(*::new FretViewWindow());
	  operator[](size()-1).createWindow(*this,String(STRING_FRETVIEWWINDOWCLASSNAME),"Fretboard","fretMenu","APP_ICON");
    getDocumentClass(String(STRING_FRETVIEWWINDOWCLASSNAME),mdiWindow);
	}
  if(!someCallbackData.lParam())
	{
    ((FretViewWindow&)*mdiWindow).clearNotes();
	}
	else
	{
	  if(!someCallbackData.wParam())
		{
	    const TabEntry &entry=*(TabEntry*)someCallbackData.lParam();
      ((FretViewWindow&)*mdiWindow).setNote(entry,true,true);
		}
		else if(1==someCallbackData.wParam())
		{
	    const Note &note=*(Note*)someCallbackData.lParam();
      ((FretViewWindow&)*mdiWindow).setNote(note);
		}
		else if(2==someCallbackData.wParam())   // This is used by the scale dialog
		{
		  const Scale &scale=*(Scale*)someCallbackData.lParam();
			((FretViewWindow&)*mdiWindow).setNote(scale,true);
		}
		else if(3==someCallbackData.wParam())  // not currently used see ScaleDlg
		{
		  const FrettedNotes &frettedNotes=*(FrettedNotes*)someCallbackData.lParam();
			((FretViewWindow&)*mdiWindow).setNote(frettedNotes);
		}
	}
  return 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_FILENEW,MENU_FILE_NEW,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar.addButton(ToolBarButton(STD_FILEOPEN,MENU_FILE_OPEN,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)
{
	createProjectView();
}

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

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

	if(!openDialog.getOpenFileName(*this,"*.tab","Open Tab","*.tab",strPathTabFile))return;
	createProjectView(strPathTabFile);
}

void MainFrame::handleMIDIImport(void)
{
  OpenDialog openDialog;
  String strPathMIDIFile;
	String strPathTabFileName;
	MIDIHelper midiHelper;
	CursorControl cursorControl;
  MIDIDialog midiDialog;
	License license;
	int selectedTrack;

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

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;

	if(!openDialog.getOpenFileName(*this,String(STRING_PRJALLEXTENSION),"Open Project",String(STRING_PRJALLEXTENSION),strPathFileName))return;
	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::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

bool MainFrame::preDestroy(MDIWindow &mdiWindow)
{
  GlobalDefs::outDebug("[MainFrame::preDestroy]",GlobalDefs::Verbose);
	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)
{
  GlobalDefs::outDebug("[MainFrame::mdiDestroy]",GlobalDefs::Verbose);
}

void MainFrame::mdiActivate(MDIWindow &mdiWindow)
{
  GlobalDefs::outDebug("[MainFrame::mdiActivate]",GlobalDefs::Verbose);
  removeHistory(mdiWindow.getMenu());
	applyHistory(mdiWindow.getMenu());
  if(mdiWindow.className()==String(STRING_TABVIEWWINDOWCLASSNAME))
	{
	  ViewWindow &viewWindow=(ViewWindow&)mdiWindow;
	}
}

void MainFrame::mdiDeactivate(MDIWindow &mdiWindow)
{
  GlobalDefs::outDebug("[MainFrame::mdiDeactivate]",GlobalDefs::Verbose);
}