#include <dvcap/mainwnd.hpp>
#include <common/dxsdk.hpp>
#include <common/opendlg.hpp>
#include <dvcap/dvcap.hpp>
#include <dvcap/CaptureDeviceGraph.hpp>
#include <common/assert.hpp>
#include <common/dbt.hpp>

char MainWindow::szClassName[]="DVCAP  [v1.00]";
char MainWindow::szMenuName[]="DVCAP";

MainWindow::MainWindow(void)
: mHaveDevice(false), mVideoWidth(0), mVideoHeight(0), mCapStartTime(0),
  mHours(0), mMinutes(0), mSeconds(0)
{
  mPaintHandler.setCallback(this,&MainWindow::paintHandler);
	mDestroyHandler.setCallback(this,&MainWindow::destroyHandler);
	mCommandHandler.setCallback(this,&MainWindow::commandHandler);
	mKeyDownHandler.setCallback(this,&MainWindow::keyDownHandler);
	mSizeHandler.setCallback(this,&MainWindow::sizeHandler);
	mCreateHandler.setCallback(this,&MainWindow::createHandler);
	mUserHandler.setCallback(this,&MainWindow::userHandler);
	mDeviceChangeHandler.setCallback(this,&MainWindow::deviceChangeHandler);
	mATNTimerHandler.setCallback(this,&MainWindow::atnTimerHandler);
	mCapLimitTimerHandler.setCallback(this,&MainWindow::capLimitTimerHandler);
	mFramesTimerHandler.setCallback(this,&MainWindow::framesTimerHandler);
	mAtnTimer.insertHandler(&mATNTimerHandler);
	mCapLimitTimer.insertHandler(&mCapLimitTimerHandler);
	mFramesTimer.insertHandler(&mFramesTimerHandler);
	insertHandlers();
	registerClass();
	::CreateWindow(szClassName,szClassName,WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_SIZEBOX|WS_CLIPCHILDREN|WS_CLIPSIBLINGS|WS_DLGFRAME,CW_USEDEFAULT,CW_USEDEFAULT,InitialWidth,InitialHeight,NULL,NULL,processInstance(),(LPSTR)this);
	show(SW_SHOW);
  update();
}

MainWindow::~MainWindow()
{
	destroy();
}

void MainWindow::insertHandlers(void)
{
	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
	insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
	insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
	insertHandler(VectorHandler::SizeHandler,&mSizeHandler);
	insertHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
	insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
	insertHandler(VectorHandler::UserHandler,&mUserHandler);
	insertHandler(VectorHandler::DeviceChangeHandler,&mDeviceChangeHandler);
}

void MainWindow::removeHandlers(void)
{
	removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
	removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
	removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
	removeHandler(VectorHandler::SizeHandler,&mSizeHandler);
	removeHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
	removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
	removeHandler(VectorHandler::UserHandler,&mUserHandler);
	removeHandler(VectorHandler::DeviceChangeHandler,&mDeviceChangeHandler);
}

void MainWindow::registerClass(void)
{
	HINSTANCE hInstance(processInstance());
	WNDCLASS wndClass;

	if(::GetClassInfo(hInstance,className(),(WNDCLASS FAR*)&wndClass))return;
	wndClass.style         =CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS|CS_OWNDC;
	wndClass.lpfnWndProc   =(WNDPROC)Window::WndProc;
	wndClass.cbClsExtra    =0;
	wndClass.cbWndExtra    =sizeof(MainWindow*);
	wndClass.hInstance     =hInstance;
	wndClass.hIcon         =::LoadIcon(processInstance(),"DVCAP");
	wndClass.hCursor       =::LoadCursor(NULL,IDC_ARROW);
  wndClass.hbrBackground =(HBRUSH)::GetStockObject(GRAY_BRUSH);
	wndClass.lpszMenuName  =szMenuName;
	wndClass.lpszClassName =szClassName;
	::RegisterClass(&wndClass);
	assert(0!=::GetClassInfo(hInstance,className(),(WNDCLASS FAR*)&wndClass));
}

CallbackData::ReturnType MainWindow::destroyHandler(CallbackData &/*someCallbackData*/)
{
  if(mCaptureDeviceGraph.isOkay())mCaptureDeviceGraph.destroy();
  removeHandlers();
  ::PostQuitMessage(0);
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainWindow::sizeHandler(CallbackData &someCallbackData)
{
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainWindow::deviceChangeHandler(CallbackData &someCallbackData)
{
  handleDeviceChange(someCallbackData);
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainWindow::commandHandler(CallbackData &someCallbackData)
{
	switch(someCallbackData.wParam())
	{
    case DVCAPMENU_FILE_SETOUTPUT :
		  handleFileSetOutput();
		  break;
    case DVCAPMENU_FILE_SETINPUT :
		  handleFileSetInput();
		  break;
    case DVCAPMENU_FILE_SAVEGRAPH : 
		  handleFileSaveGraph();
		  break;
    case DVCAPMENU_FILE_CAPTURESIZE :
		  handleFileCaptureSize();
		  break;
    case DVCAPMENU_FILE_EXIT :
		  sendMessage(WM_CLOSE,0,0L);
		  break;
    case DVCAPMENU_MODE_PREVIEW :
		  handleModePreview();
		  break;
    case DVCAPMENU_MODE_DVTOFILE :
		  handleModeDVToFile();
		  break;
    case DVCAPMENU_MODE_DVTOFILE_NOPRE :
		  handleModeDVToFileNoPre();
		  break;
    case DVCAPMENU_MODE_FILETODV :
		  handleModeFileToDV();
		  break;
    case DVCAPMENU_MODE_FILETODV_NOPRE :
		  handleModeFileToDVNoPre();
		  break;
    case DVCAPMENU_MODE_DVTOFILE_TYPE2 :
		  handleModeDVToFileType2();
		  break;
    case DVCAPMENU_MODE_DVTOFILE_NOPRE_TYPE2 :
		  handleModeDVToFileNoPreType2();
		  break; 
    case DVCAPMENU_MODE_FILETODV_TYPE2 :
		  handleModeFileToDVType2();
		  break;
    case DVCAPMENU_MODE_FILETODV_NOPRE_TYPE2 :
		  handleModeFileToDVNoPreType2();
		  break;
    case DVCAPMENU_OPTIONS_REFRESH_MODE : 
		  handleOptionsRefreshMode();
		  break;
    case DVCAPMENU_OPTIONS_CHECK_TAPE :
		  handleOptionsCheckTape();
		  break;
    case DVCAPMENU_OPTIONS_DECODE_SIZE :
		  handleOptionsDecodeSize();
		  break;
    case DVCAPMENU_OPTIONS_FRAME_RATE :
		  handleOptionsFrameRate();
		  break;
    case DVCAPMENU_HELP_ABOUT :
		  handleHelpAbout();
	    break;
		case IDM_PLAY :
		  handlePlay();
		  break;
		case IDM_PAUSE :
		  handlePause();
		  break;
		case IDM_STOP :
		  handleStop();
		  break;
		case IDM_RECORD :
		  handleRecord();
		  break;
		case IDM_FORWARD :
		  handleForward();
		  break;
		case IDM_REVERSE :
		  handleReverse();
		  break;
		case IDM_FORWARDFASTEST :
		  handleForwardFastest();
		  break;
		case IDM_SKIPNEXT :
		  handleSkipNext();
		  break;
		case IDM_SKIPPREV :
		  handleSkipPrev();
		  break;
		case IDM_REVERSEFASTEST :
		  handleReverseFastest();
		  break;
		case IDM_SEEKATN :
		  handleSeekATN();
		  break;
		default :
      break;
	}
	return (CallbackData::ReturnType)FALSE;
}

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

CallbackData::ReturnType MainWindow::createHandler(CallbackData &/*someCallbackData*/)
{
  mAppMenu=getMenu();
  mToolBar=::new ToolBar();
	mToolBar.disposition(PointerDisposition::Delete);
  mToolBar->create(*this,ToolBarID);
	mToolBar->addBitmap(AddBitmap("TOOLBAR"));
	mToolBar->addButton(ToolBarButton(0,IDM_PLAY,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar->addButton(ToolBarButton(1,IDM_PAUSE,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar->addButton(ToolBarButton(2,IDM_STOP,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar->addButton(ToolBarButton(3,IDM_RECORD,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar->addButton(ToolBarButton(4,IDM_FORWARD,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar->addButton(ToolBarButton(5,IDM_REVERSE,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar->addButton(ToolBarButton(6,IDM_FORWARDFASTEST,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar->addButton(ToolBarButton(7,IDM_SKIPNEXT,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar->addButton(ToolBarButton(8,IDM_SKIPPREV,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar->addButton(ToolBarButton(9,IDM_REVERSEFASTEST,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mToolBar->addButton(ToolBarButton(10,IDM_SEEKATN,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
	mStatusBar=::new StatusBarEx(*this,StatusBarID);
	mStatusBar.disposition(PointerDisposition::Delete);
	setParts();
	mDeviceNotification.registerDeviceNotification(*this);
	mCaptureDeviceGraph=::new CaptureDeviceGraph();
	mCaptureDeviceGraph.disposition(PointerDisposition::Delete);
	dvAppSetup(mCaptureDeviceGraph->buildBasicGraph());

  int left=350;
  Rect initRect;
	mEdit1=::new Control();
	mEdit1.disposition(PointerDisposition::Delete);
	initRect=Rect(left,2,25,22);
	mEdit1->createControl(WS_EX_CLIENTEDGE,"edit","00",WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP|ES_NUMBER,initRect,*mToolBar,EditHourID);

	mEdit2=::new Control();
	mEdit2.disposition(PointerDisposition::Delete);
	initRect=Rect(left+25,2,25,22);
	mEdit2->createControl(WS_EX_CLIENTEDGE,"edit","00",WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP|ES_NUMBER,initRect,*mToolBar,EditMinuteID);

	mEdit3=::new Control();
	mEdit3.disposition(PointerDisposition::Delete);
	initRect=Rect(left+48,2,25,22);
	mEdit3->createControl(WS_EX_CLIENTEDGE,"edit","00",WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP|ES_NUMBER,initRect,*mToolBar,EditSecondID);

	mEdit4=::new Control();
	mEdit4.disposition(PointerDisposition::Delete);
	initRect=Rect(left+71,2,25,22);
	mEdit4->createControl(WS_EX_CLIENTEDGE,"edit","00",WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP|ES_NUMBER,initRect,*mToolBar,EditFrameID);

  mTCButton=::new Control();
	mTCButton.disposition(PointerDisposition::Delete);
	initRect=Rect(left+100,2,190,22);
	mTCButton->createControl("button","Display Timecodes",WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP|ES_NUMBER,initRect,*mToolBar,TCButtonID);
	mTCButton->sendMessage(BM_SETCHECK,true,0L);

  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainWindow::paintHandler(CallbackData &someCallbackData)
{
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MainWindow::userHandler(CallbackData &someCallbackData)
{
  switch(someCallbackData.wParam())
	{
	  case WM_FGNOTIFY :
			break;
	}
	return (CallbackData::ReturnType)FALSE;
}

// begin timer handlers

CallbackData::ReturnType MainWindow::atnTimerHandler(CallbackData &someCallbackData)
{
  return true;
}

CallbackData::ReturnType MainWindow::capLimitTimerHandler(CallbackData &someCallbackData)
{
  return true;
}

CallbackData::ReturnType MainWindow::framesTimerHandler(CallbackData &someCallbackData)
{
  return true;
}

// end timer handlers

void MainWindow::setParts()
{
  GlobalData<int> parts;
  int partWidth=width()/3;
	parts.size(3);
	parts[0]=partWidth;
	parts[1]=parts[0]+partWidth;
	parts[2]=parts[1]+partWidth;
	mStatusBar->setParts(parts);
}

void MainWindow::handleDeviceChange(CallbackData &cbData)
{
  PDEV_BROADCAST_HDR pDevBroadcastHeader=0;
	PDEV_BROADCAST_DEVICEINTERFACE pDevBroadcastInterface=0;
  if(DBT_DEVICEARRIVAL!=cbData.wParam())return;
	dvStatusText("Detected new capture device.");
	mStatusBar->update();
	pDevBroadcastHeader=(PDEV_BROADCAST_HDR)cbData.lParam();
	if(DBT_DEVTYP_DEVICEINTERFACE!=pDevBroadcastHeader->dbch_devicetype)return;
  pDevBroadcastInterface=(PDEV_BROADCAST_DEVICEINTERFACE)cbData.lParam();
	if(pDevBroadcastInterface->dbcc_classguid!=AM_KSCATEGORY_CAPTURE)return;
	if(!mHaveDevice)
	{
	  message("New capture device detected");
	  mCaptureDeviceGraph=::new CaptureDeviceGraph();
		mCaptureDeviceGraph.disposition(PointerDisposition::Delete);
		dvAppSetup(mCaptureDeviceGraph->buildBasicGraph());
	}
}

void MainWindow::handleFileSaveGraph(void)
{
}

void MainWindow::handleFileSetInput(void)
{
  OpenDialog openDialog;
	String pathFileName;

  if(!openDialog.getOpenFileName(*this,"Microsoft AVI\0*.avi\0\0","Set Output File Name","Capture.avi",pathFileName))return;
	mInputFileName=pathFileName;
}

bool MainWindow::handleFileSetOutput(void)
{
  OpenDialog openDialog;
	String pathFileName;

  if(!openDialog.getSaveFileName(*this,"Microsoft AVI\0*.avi\0\0","Set Output File Name","Capture.avi",pathFileName))
	  return false;
	mOutputFileName=pathFileName;
	return true;
}

void MainWindow::handleFileCaptureSize()
{
}

void MainWindow::handleModePreview()
{
}

void MainWindow::handleModeDVToFile()
{
	if(mOutputFileName.isNull()&&!handleFileSetOutput())return;
  if(CaptureDeviceGraph::GraphDVToFile==mGraphType)return;  
	if(!mCaptureDeviceGraph->stopGraph())return;
	mCaptureDeviceGraph->nukeDeviceFilter();
  if(!mCaptureDeviceGraph->makeDVToFileGraphType1(mOutputFileName))
	{
	  message("MakeDVToFileGraphType1() Failed");
		return;
	}
	setPreviewWindow();
	markGraphModeMenu(DVCAPMENU_MODE_DVTOFILE);
	markToolBarButton(true,true);
}

void MainWindow::handleModeDVToFileNoPre()
{
}

void MainWindow::handleModeFileToDV()
{
}

void MainWindow::handleModeFileToDVNoPre()
{
}

void MainWindow::handleModeDVToFileType2()
{
	if(mOutputFileName.isNull()&&!handleFileSetOutput())return;
  if(CaptureDeviceGraph::GraphDVToFileType2==mGraphType)return;  
	if(!mCaptureDeviceGraph->stopGraph())return;
	mCaptureDeviceGraph->nukeDeviceFilter();
  if(!mCaptureDeviceGraph->makeDVToFileGraphType2(mOutputFileName))
	{
	  message("MakeDVToFileGraphType2() Failed");
		return;
	}
	setPreviewWindow();
	markGraphModeMenu(DVCAPMENU_MODE_DVTOFILE_TYPE2);
	markToolBarButton(true,false);
}

void MainWindow::handleModeDVToFileNoPreType2()
{
}

void MainWindow::handleModeFileToDVType2()
{
}

void MainWindow::handleModeFileToDVNoPreType2()
{
}

void MainWindow::handleOptionsRefreshMode()
{
}

void MainWindow::handleOptionsCheckTape()
{
}

void MainWindow::handleOptionsDecodeSize()
{
}

void MainWindow::handleOptionsFrameRate()
{
}

void MainWindow::handleHelpAbout()
{
}

// start transport handlers

void MainWindow::handlePlay()
{
  if(CaptureDeviceGraph::GraphFileToDV==mGraphType || 
	   CaptureDeviceGraph::GraphFileToDVNoPre==mGraphType ||
		 CaptureDeviceGraph::GraphFileToDVType2==mGraphType ||
		 CaptureDeviceGraph::GraphFileToDVNoPreType2==mGraphType)
  {
	  mToolBar->setState(IDM_PLAY,ToolBar::Indeterminate);
	  mCapStartTime=::GetTickCount();
	  mFramesTimer.startTimer(TimerResolution);
	  mCaptureDeviceGraph->startGraph();
	}
	else
	{
	  dvPutVcrMode(ED_MODE_PLAY); 
	  if(CaptureDeviceGraph::GraphPreview==mGraphType)mCaptureDeviceGraph->startGraph();
		if(BST_CHECKED==mTCButton->sendMessage(BM_GETCHECK,0,0L))
		  mAtnTimer.startTimer(TimerResolution);
  }
}

void MainWindow::handleStop()
{
  mAtnTimer.stopTimer();
	mCapLimitTimer.stopTimer();
	mFramesTimer.stopTimer();
	mCaptureDeviceGraph->stopGraph();
	dvPutVcrMode(ED_MODE_STOP);
	mToolBar->setState(IDM_PLAY,ToolBar::Enabled);
  mToolBar->setState(IDM_SKIPNEXT,ToolBar::Indeterminate);
  mToolBar->setState(IDM_SKIPPREV,ToolBar::Indeterminate);
}

void MainWindow::handlePause(void)
{
  if(CaptureDeviceGraph::GraphFileToDV==mGraphType || 
	   CaptureDeviceGraph::GraphFileToDVNoPre==mGraphType ||
		 CaptureDeviceGraph::GraphFileToDVType2==mGraphType ||
		 CaptureDeviceGraph::GraphFileToDVNoPreType2==mGraphType)
  {
	  mCaptureDeviceGraph->pauseGraph();
	}
	else
	{
	  dvPutVcrMode(ED_MODE_FREEZE);
		mToolBar->setState(IDM_SKIPNEXT,ToolBar::Enabled);
		mToolBar->setState(IDM_SKIPPREV,ToolBar::Enabled);
	}
}

void MainWindow::handleForward()
{
  dvPutVcrMode(ED_MODE_PLAY_FASTEST_FWD);
	mToolBar->setState(IDM_SKIPNEXT,ToolBar::Indeterminate);
	mToolBar->setState(IDM_SKIPPREV,ToolBar::Indeterminate);
}

void MainWindow::handleReverse()
{
  dvPutVcrMode(ED_MODE_PLAY_FASTEST_REV);
	mToolBar->setState(IDM_SKIPNEXT,ToolBar::Indeterminate);
	mToolBar->setState(IDM_SKIPPREV,ToolBar::Indeterminate);
}

void MainWindow::handleForwardFastest()
{
  dvPutVcrMode(ED_MODE_FF);
	mToolBar->setState(IDM_SKIPNEXT,ToolBar::Indeterminate);
  mToolBar->setState(IDM_SKIPPREV,ToolBar::Indeterminate);	
}

void MainWindow::handleSkipNext()
{
	mAtnTimer.stopTimer();
  dvPutVcrMode(ED_MODE_STEP_FWD);
	dvDisplayTimecode();
}

void MainWindow::handleSkipPrev()
{
	mAtnTimer.stopTimer();
  dvPutVcrMode(ED_MODE_STEP_REV);
	dvDisplayTimecode();
}

void MainWindow::handleReverseFastest()
{
  dvPutVcrMode(ED_MODE_REW);
	mToolBar->setState(IDM_SKIPNEXT,ToolBar::Indeterminate);
	mToolBar->setState(IDM_SKIPPREV,ToolBar::Indeterminate);
}

void MainWindow::handleSeekATN()
{
  dvSeekAtn();         // this needs to be completed
	dvDisplayTimecode();
}

void MainWindow::handleRecord()
{
  message("Record");
}

/*

        case IDM_RECORD :
            // update the toolbar accordingly
            SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_FWD, MAKELONG(TBSTATE_INDETERMINATE, 0L));
            SendMessage(g_hwndTBar, TB_SETSTATE, IDM_STEP_REV, MAKELONG(TBSTATE_INDETERMINATE, 0L));

            // check to see if it is a capture graph
            if (GRAPH_DV_TO_FILE == g_iGraphType || GRAPH_DV_TO_FILE_NOPRE == g_iGraphType ||
                GRAPH_DV_TO_FILE_TYPE2 == g_iGraphType || GRAPH_DV_TO_FILE_NOPRE_TYPE2 == g_iGraphType)
            {
                //do something here to record to an avi file on the disk - or to start recording on the vcr.
                switch (g_dwCaptureLimit)
                {
                    case DV_CAPLIMIT_NONE :
                        break;
                    case DV_CAPLIMIT_TIME :
                        SetTimer(hwnd, DV_TIMER_CAPLIMIT, g_dwTimeLimit * 1000, (TIMERPROC) DV_StopRecProc);
                        break;
                    case DV_CAPLIMIT_SIZE :
                        //rather than monitor disk usage, we'll just do the math and set a timer
                        SetTimer(hwnd, DV_TIMER_CAPLIMIT, ((g_dwDiskSpace * 100000) / DV_BYTESPERMSEC), (TIMERPROC) DV_StopRecProc);
                        break;
                    default :
                        //MBOX(TEXT("Bad value for g_dwCaptureLimit (%d)"), g_dwCaptureLimit);
                        break;
                }
                //update the status bar with the dropped frames information
                g_CapStartTime = GetTickCount();
                SetTimer(hwnd, DV_TIMER_FRAMES,  DV_TIMERFREQ, (TIMERPROC) DV_DroppedFrameProc);
                //run the graph - assume that the camera is already playing if in Vcr mode
                g_pGraph->StartGraph();
            }
            else if (GRAPH_FILE_TO_DV == g_iGraphType || GRAPH_FILE_TO_DV_NOPRE == g_iGraphType ||
                     GRAPH_FILE_TO_DV_TYPE2 == g_iGraphType || GRAPH_FILE_TO_DV_NOPRE_TYPE2 == g_iGraphType)
            {
                // if transmit graph then record on tape of the device
                DV_PutVcrMode(ED_MODE_RECORD);
            }
            else
            {
                //we shouldn't get here
                MBOX( TEXT("Undefined graph mode (maybe GRAPH_PREVIEW) in IDM_RECORD message"));
            }
            break;

*/

// end transport handlers

void MainWindow::dvAppSetup(bool graphResult)
{
  int appWidth;
	int appHeight;

  if(!graphResult)
	{
	  message("No DV camcorder devices detected");
		mHaveDevice=false;
		mToolBar->show(SW_HIDE);
		mAppMenu.enableMenuItem(DVCAPMENU_OPTIONS_REFRESH_MODE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
		mAppMenu.enableMenuItem(DVCAPMENU_OPTIONS_CHECK_TAPE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
		mAppMenu.enableMenuItem(DVCAPMENU_OPTIONS_DECODE_SIZE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_PREVIEW,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_DVTOFILE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_DVTOFILE_NOPRE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_FILETODV,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_FILETODV_NOPRE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_DVTOFILE_TYPE2,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_DVTOFILE_NOPRE_TYPE2,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_FILETODV_TYPE2,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_FILETODV_NOPRE_TYPE2,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
	}
	else
	{
	  mHaveDevice=true;

		mToolBar->show(SW_SHOWNORMAL);
		mAppMenu.enableMenuItem(DVCAPMENU_OPTIONS_REFRESH_MODE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
		mAppMenu.enableMenuItem(DVCAPMENU_OPTIONS_CHECK_TAPE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
		mAppMenu.enableMenuItem(DVCAPMENU_OPTIONS_DECODE_SIZE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_PREVIEW,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_DVTOFILE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_DVTOFILE_NOPRE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_FILETODV,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_FILETODV_NOPRE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_DVTOFILE_TYPE2,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_DVTOFILE_NOPRE_TYPE2,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_FILETODV_TYPE2,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
		mAppMenu.enableMenuItem(DVCAPMENU_MODE_FILETODV_NOPRE_TYPE2,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
		dvRefreshMode();
		dvStatusText(mCaptureDeviceGraph->getDeviceName().toString());
		if(!mCaptureDeviceGraph->makePreviewGraph())
		{
		  message("MakePreviewGraph() Failed.");
			return;
		}
    mCaptureDeviceGraph->getVideoWindowDimensions(mVideoWidth,mVideoHeight);
		appWidth=mVideoWidth+WidthEdge;
		appHeight=mVideoHeight+HeightEdge;		
		postMessage(*this,WM_SIZE,SIZE_RESTORED,MAKELONG(appWidth,appHeight));
    if(!mCaptureDeviceGraph->setNotifyWindow(*this,WM_FGNOTIFY))
		{
      message("SetNotifyWindow Failed.");
      return;
		}
		mGraphType=CaptureDeviceGraph::GraphPreview;
		markGraphModeMenu(DVCAPMENU_MODE_PREVIEW);
		markToolBarButton(false,true);
		setPreviewWindow();
	}
}

bool MainWindow::dvRefreshMode()
{
  CaptureDeviceGraph::DVMode subunitMode;
	bool returnCode=false;
	
	if(!mCaptureDeviceGraph.isOkay())return false;
	subunitMode=mCaptureDeviceGraph->getDVMode();
	switch(subunitMode)
	{
	  case CaptureDeviceGraph::CameraMode :
		  mAppMenu.enableMenuItem(DVCAPMENU_MODE_FILETODV,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
		  mAppMenu.enableMenuItem(DVCAPMENU_MODE_FILETODV_NOPRE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
		  mAppMenu.enableMenuItem(DVCAPMENU_MODE_FILETODV_TYPE2,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
		  mAppMenu.enableMenuItem(DVCAPMENU_MODE_FILETODV_NOPRE_TYPE2,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
		  mAppMenu.enableMenuItem(DVCAPMENU_OPTIONS_CHECK_TAPE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemGrayed|PureMenu::ItemDisabled));
			dvStatusText("Camera Mode.");
			returnCode=true;
		  break;
		case CaptureDeviceGraph::VCRMode :
		  dvUpdateTapeInfo();
		  mAppMenu.enableMenuItem(DVCAPMENU_MODE_FILETODV,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
		  mAppMenu.enableMenuItem(DVCAPMENU_MODE_FILETODV_NOPRE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
		  mAppMenu.enableMenuItem(DVCAPMENU_MODE_FILETODV_TYPE2,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
		  mAppMenu.enableMenuItem(DVCAPMENU_MODE_FILETODV_NOPRE_TYPE2,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
		  mAppMenu.enableMenuItem(DVCAPMENU_OPTIONS_CHECK_TAPE,PureMenu::ByCommand,PureMenu::InsertFlags(PureMenu::ItemEnabled));
			dvStatusText("VCR Mode.");
			returnCode=true;
			break;
		case CaptureDeviceGraph::UnknownMode :
      dvStatusText("Unknown Mode.");		  
		  break;
	}
	return returnCode;
}

bool MainWindow::dvUpdateTapeInfo()
{
	if(!mCaptureDeviceGraph.isOkay())return false;
	if(!mCaptureDeviceGraph->getTapeInfo())
	{
	  dvStatusText("VCR Mode - No tape, or unknown format");
		return false;
	}
	switch(mCaptureDeviceGraph->getVideoFormat())
	{
	  case DVENCODERVIDEOFORMAT_NTSC :
		  dvStatusText("VCR Mode - NTSC");
		  break;
		case DVENCODERVIDEOFORMAT_PAL :
		  dvStatusText("VCR Mode - PAL");
		  break;
		default :
		  dvStatusText("Unsupported or unrecognized tape format type.");
		  break;
	}
	return true;
}

bool MainWindow::setPreviewWindow(void)
{
  Rect cliRect;
	Rect tbRect;

  if(!mCaptureDeviceGraph.isOkay())return false;
	if(!mCaptureDeviceGraph->putOwner(*this))return false;
	if(!mCaptureDeviceGraph->putWindowStyle(WS_CHILD|WS_CLIPSIBLINGS))return false;
	clientRect(cliRect);
	mToolBar->clientRect(tbRect);
	if(!mCaptureDeviceGraph->setVideoWindowPosition(0,tbRect.bottom()-tbRect.top(),mVideoWidth,mVideoHeight))return false;
	if(!mCaptureDeviceGraph->setVideoWindowVisible(true))return false;
	return true;
}

void MainWindow::markGraphModeMenu(int itemID)
{
  mAppMenu.checkMenuItem(DVCAPMENU_MODE_PREVIEW,PureMenu::ItemUnchecked);
  mAppMenu.checkMenuItem(DVCAPMENU_MODE_FILETODV,PureMenu::ItemUnchecked);
  mAppMenu.checkMenuItem(DVCAPMENU_MODE_DVTOFILE,PureMenu::ItemUnchecked);
  mAppMenu.checkMenuItem(DVCAPMENU_MODE_FILETODV_NOPRE,PureMenu::ItemUnchecked);
  mAppMenu.checkMenuItem(DVCAPMENU_MODE_DVTOFILE_NOPRE,PureMenu::ItemUnchecked);
  mAppMenu.checkMenuItem(DVCAPMENU_MODE_FILETODV_TYPE2,PureMenu::ItemUnchecked);
  mAppMenu.checkMenuItem(DVCAPMENU_MODE_FILETODV_NOPRE_TYPE2,PureMenu::ItemUnchecked);
  mAppMenu.checkMenuItem(DVCAPMENU_MODE_DVTOFILE_TYPE2,PureMenu::ItemUnchecked);
  mAppMenu.checkMenuItem(DVCAPMENU_MODE_DVTOFILE_NOPRE_TYPE2,PureMenu::ItemUnchecked);
  mAppMenu.checkMenuItem(itemID,PureMenu::ItemChecked);
}

void MainWindow::markToolBarButton(bool enableRecord,bool enableOthers)
{
  if(true==enableRecord)mToolBar->setState(IDM_RECORD,ToolBar::Enabled);
	else mToolBar->setState(IDM_RECORD,ToolBar::Indeterminate);
	if(enableOthers)
	{
	  mToolBar->setState(IDM_SKIPPREV,ToolBar::Enabled);
		mToolBar->setState(IDM_REVERSEFASTEST,ToolBar::Enabled);
		mToolBar->setState(IDM_REVERSE,ToolBar::Enabled);
		mToolBar->setState(IDM_FORWARD,ToolBar::Enabled);
		mToolBar->setState(IDM_FORWARDFASTEST,ToolBar::Enabled);
	  mToolBar->setState(IDM_SKIPNEXT,ToolBar::Enabled);
	  mToolBar->setState(IDM_SEEKATN,ToolBar::Enabled);
	}
	else
	{
	  mToolBar->setState(IDM_SKIPPREV,ToolBar::Indeterminate);
		mToolBar->setState(IDM_REVERSEFASTEST,ToolBar::Indeterminate);
		mToolBar->setState(IDM_REVERSE,ToolBar::Indeterminate);
		mToolBar->setState(IDM_FORWARD,ToolBar::Indeterminate);
		mToolBar->setState(IDM_FORWARDFASTEST,ToolBar::Indeterminate);
	  mToolBar->setState(IDM_SKIPNEXT,ToolBar::Indeterminate);
	  mToolBar->setState(IDM_SEEKATN,ToolBar::Indeterminate);
	}
}

bool MainWindow::dvPutVcrMode(int mode)
{
  if(!mCaptureDeviceGraph.isOkay())return false;
  return mCaptureDeviceGraph->putIAMExtTransportMode(mode);
}

bool MainWindow::dvSeekAtn(void)
{
  int status=false;
	int hour;
	int minute;
	int second;
	int frame;

  hour=::GetDlgItemInt(*mToolBar,EditHourID,&status,false);  
	minute=::GetDlgItemInt(*mToolBar,EditMinuteID,&status,false); 
	second=::GetDlgItemInt(*mToolBar,EditSecondID,&status,false); 
	frame=::GetDlgItemInt(*mToolBar,EditFrameID,&status,false); 
	if(!mCaptureDeviceGraph->seekAtn(hour,minute,second,frame))
	{
	  message("Seek Failed - Time should be :\nHour:Minute:Second:Frame");
		return false;
	}
	return true;
} 

// this called through both menu selections and timer callback

bool MainWindow::dvDisplayTimecode(void)
{
  TIMECODE_SAMPLE tcSample;

	tcSample.timecode.dwFrames=0;
	tcSample.dwFlags=ED_DEVCAP_TIMECODE_READ;
	if(!mCaptureDeviceGraph->getTimecode(tcSample))return false;
	if(mHours!=(tcSample.timecode.dwFrames&0xFF000000)>>24)
	{
	  ::sprintf(mStrTimecode.str(),"%.2x",(tcSample.timecode.dwFrames&0xFF000000)>>24);
		::SetDlgItemText(*mToolBar,EditHourID,mStrTimecode.str());
	}
	mHours=(tcSample.timecode.dwFrames&0xFF000000)>>24;

	if(mMinutes!=(tcSample.timecode.dwFrames&0x00FF0000)>>16)
	{
	  ::sprintf(mStrTimecode.str(),"%.2x",(tcSample.timecode.dwFrames&0x00FF0000)>>16);
		::SetDlgItemText(*mToolBar,EditMinuteID,mStrTimecode.str());
	}
	mMinutes=(tcSample.timecode.dwFrames&0x00FF0000)>>16;

	if(mSeconds!=(tcSample.timecode.dwFrames&0x0000FF00)>>8)
	{
	  ::sprintf(mStrTimecode.str(),"%.2x",(tcSample.timecode.dwFrames&0x0000FF00)>>8);
		::SetDlgItemText(*mToolBar,EditMinuteID,mStrTimecode.str());
	}
	mSeconds=(tcSample.timecode.dwFrames&0x0000FF00)>>8;

  ::sprintf(mStrTimecode.str(),"%.2x",(tcSample.timecode.dwFrames & 0x000000FF));
	::SetDlgItemText(*mToolBar,EditFrameID,mStrTimecode.str());
  return true;
}

/*
void MainWindow::disconnect(CaptureDeviceGraph::GraphType graphType)
{
  if(CaptureDeviceGraph::GraphFileToDV==graphType ||
	   CaptureDeviceGraph::GraphFileToDVNoPre==graphType ||
		 CaptureDeviceGraph::GraphFileToDVType2==graphType ||
		 CaptureDeviceGraph::GraphFileToDVNoPreType2==graphType)
	{
	  mCaptureDeviceGraph->nukeFilters();
	}
	else
	{
	}
	   


*/

/*

    if (GRAPH_FILE_TO_DV == g_iGraphType || GRAPH_FILE_TO_DV_NOPRE == g_iGraphType ||
        GRAPH_FILE_TO_DV_TYPE2 == g_iGraphType || GRAPH_FILE_TO_DV_NOPRE_TYPE2 == g_iGraphType)
    {
        //DisconnectAll removes only the downstream filters - we need to remove the file filter by hand.
         g_pGraph->NukeFilters( g_pGraph->m_pInputFileFilter, TRUE);
        if (g_pGraph->m_pInputFileFilter )
        {
            g_pGraph->m_pGraph->RemoveFilter( g_pGraph->m_pInputFileFilter );
            SAFE_RELEASE( g_pGraph->m_pInputFileFilter );
        }
    }
    else
    {
        //DisconnectAll removes only the downstream filters
        hr = g_pGraph->NukeFilters( g_pGraph->m_pDeviceFilter, TRUE);
        if(FAILED(hr))
        {
            MBOX(TEXT("nukefilters() failed"));
        }
    }


*/


//	typedef enum GraphType{GraphPreview,GraphDVToFile,GraphDVToFileNoPre,GraphFileToDV,GraphFileToDVNoPre,
//	  GraphDVToFileType2,GraphDVToFileNoPreType2,GraphFileToDVType2,GraphFileToDVNoPreType2};

/*
}

*/