884 lines
30 KiB
C++
884 lines
30 KiB
C++
#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};
|
|
|
|
/*
|
|
}
|
|
|
|
*/
|