// Demo.cpp : Defines the class behaviors for the application.
//

#include "stdafx.h"
#include "demo.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
L_BOOL RegisterAppKey ( HINSTANCE hInstance );
#define REG_KEYS 2
/////////////////////////////////////////////////////////////////////////////
// CDemo

BOOL CDemo::m_bIsPdfDpiSet = FALSE;

BEGIN_MESSAGE_MAP(CDemo, CWinApp)
   //{{AFX_MSG_MAP(CDemo)
   ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
   ON_COMMAND(ID_EDIT_PASTE, OnEditPaste)
   ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, OnUpdateEditPaste)
   ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
   ON_COMMAND(ID_FILE_ALL_ERROR, OnFileAllError)
   ON_COMMAND(ID_FILE_LAST_ERROR, OnFileLastError)
   ON_UPDATE_COMMAND_UI(ID_FILE_ALL_ERROR, OnUpdateFileAllError)
   ON_UPDATE_COMMAND_UI(ID_FILE_LAST_ERROR, OnUpdateFileLastError)
   ON_COMMAND(ID_WINDOW_CLOSEALL, OnWindowCloseAll)
	ON_COMMAND(IDM_CONVERT, OnConvert)
	ON_COMMAND(ID_FILE_OPENMRC, OnFileOpenmrc)
	//}}AFX_MSG_MAP
   // Standard file based document commands
   ON_COMMAND(ID_FILE_NEW, CWinApp::OnFileNew)
   ON_COMMAND(ID_FILE_OPEN, CWinApp::OnFileOpen)
   // Standard print setup command
   ON_COMMAND(ID_FILE_PRINT_SETUP, CWinApp::OnFilePrintSetup)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// utilities

//utility
extern L_VOID NormalizeRect(RECT* pRect)
{
   L_INT nTemp;
   if (pRect->left > pRect->right)
   {
      nTemp = pRect->left;
      pRect->left = pRect->right;
      pRect->right = nTemp;
   }
   
   if (pRect->top > pRect->bottom)
   {
      nTemp = pRect->top;
      pRect->top = pRect->bottom;
      pRect->bottom = nTemp;
   }
}

//utility
extern L_VOID ChangeToImage(LUserBitmapWindow* pbitmap,  RECT* pRect)
{
   L_FLOAT fFactor = pbitmap->m_fZoom / 100.0f ;
   
   pRect->left = (L_INT)(pRect->left / fFactor + 0.5);
   pRect->top = (L_INT)(pRect->top / fFactor + 0.5);
   pRect->right = (L_INT)(pRect->right / fFactor + 0.5);
   pRect->bottom = (L_INT)(pRect->bottom / fFactor + 0.5);
   
   pRect->left = max(0, pRect->left);
   pRect->top = max(0, pRect->top);

   pRect->right = min(pbitmap->GetWidth(), pRect->right);
   pRect->bottom = min(pbitmap->GetHeight(), pRect->bottom);
}

//utility
extern L_VOID ChangeToZoom(LUserBitmapWindow* pbitmap,  RECT* pRect)
{
   L_FLOAT fFactor = pbitmap->m_fZoom / 100.0f ;
   
   pRect->left = (L_INT)(pRect->left * fFactor + 0.5);
   pRect->top = (L_INT)(pRect->top * fFactor + 0.5);
   pRect->right = (L_INT)(pRect->right * fFactor + 0.5);
   pRect->bottom = (L_INT)(pRect->bottom * fFactor + 0.5);
}


/////////////////////////////////////////////////////////////////////////////
// CDemo construction

CDemo::CDemo()
{
   m_LDialogBase.EnablePreview(FALSE);

   m_bDlgEnablePreview  = TRUE;
   m_bPaintWhileLoad    = FALSE;

   m_uPicturizeFlag     = PICTURIZE_LOADALL | PICTURIZE_RESAMPLE ;
   m_bEnableAutoSize    = FALSE;

   m_bLoadRotated       = FALSE ;
   m_bLoadCompressed    = FALSE ;

   m_bDICOMLoadMsg      = TRUE;
   m_bDICOMSaveMsg      = TRUE;

   memset(m_szCurScanDriver,0,sizeof(m_szCurScanDriver));

   LBase::LoadLibraries(LT_KRN);
   LBase::LoadLibraries(LT_FIL);
   LBase::LoadLibraries(LT_DLG);
   LBase::LoadLibraries(LT_SGM);
   LBase::LoadLibraries(LT_IMG);
   LBase::LoadLibraries(LT_DIS);
   

   LBase::SetErrorListDepth(100);
   
   WRPUNLOCKSUPPORT();
   LDialogBase::Initialize(DLG_INIT_COLOR);

   memset(&SegExtOptions,0,sizeof(SegExtOptions));
}

CDemo::~CDemo()
{
   LDialogBase::Free();
   LBase::UnloadLibraries(LT_KRN);
   LBase::UnloadLibraries(LT_FIL);
   LBase::UnloadLibraries(LT_DLG);
   LBase::UnloadLibraries(LT_SGM);
   LBase::UnloadLibraries(LT_DIS);
   LBase::UnloadLibraries(LT_IMG);
}

/////////////////////////////////////////////////////////////////////////////
// The one and only CDemo object


   CDemo theApp;

/////////////////////////////////////////////////////////////////////////////
// CDemo initialization

BOOL CDemo::InitInstance()
{
   // Standard initialization
   // If you are not using these features and wish to reduce the size
   //  of your final executable, you should remove from the following
   //  the specific initialization routines you do not need.

#ifdef _AFXDLL
   Enable3dControls();        // Call this when using MFC in a shared DLL
#else
   Enable3dControlsStatic();  // Call this when linking to MFC statically
#endif

   // Change the registry key under which our settings are stored.
   // You should modify this string to be something appropriate
   // such as the name of your company or organization.
   SetRegistryKey(_T("Main LEADTools ClassLIB DEMO"));

   LoadStdProfileSettings();  // Load standard INI file options (including MRU)

   // Register the application's document templates.  Document templates
   //  serve as the connection between documents, frame windows and views.

   CMultiDocTemplate* pDocTemplate;
   pDocTemplate = new CMultiDocTemplate(
      IDR_MFCDEMTYPE,
      RUNTIME_CLASS(CDemoDoc),
      RUNTIME_CLASS(CChildFrame), // custom MDI child frame
      RUNTIME_CLASS(CDemoView));
   AddDocTemplate(pDocTemplate);

   // create main MDI Frame window
   CMainFrame* pMainFrame = new CMainFrame;
   if (!pMainFrame->LoadFrame(IDR_MAINFRAME))
      return FALSE;
   m_pMainWnd = pMainFrame;


   // Parse command line for standard shell commands, DDE, file open
   CCommandLineInfo cmdInfo;
   cmdInfo.m_nShellCommand = CCommandLineInfo::FileNothing;
   ParseCommandLine(cmdInfo);
   m_strFileName = cmdInfo.m_strFileName;
   // Dispatch commands specified on the command line
   if (!ProcessShellCommand(cmdInfo))
      return FALSE;

   // The main window has been initialized, so show and update it.
   pMainFrame->ShowWindow(m_nCmdShow);
   pMainFrame->UpdateWindow();

   if (!m_strFileName.IsEmpty())
   {
      //OnFileNew();
      m_DoucumentMode = DOCUMENT_MODE_FILE;
      POSITION pos = GetFirstDocTemplatePosition();
      CDocTemplate* pDocTemplate = GetNextDocTemplate(pos);
      pDocTemplate->OpenDocumentFile(m_strFileName);
   }
   RegisterAppKey(this->m_hInstance);


   //setting default resolution for loading PDF files
   FILEPDFOPTIONS PdfOptions;
   memset( &PdfOptions,0,sizeof(FILEPDFOPTIONS));

   LFileSettings::GetPDFOptions( &PdfOptions, sizeof(FILEPDFOPTIONS) );
   PdfOptions.nXResolution = PDF_DPI_X_RESOLUTION;
   PdfOptions.nYResolution = PDF_DPI_Y_RESOLUTION;
   LFileSettings::SetPDFOptions( &PdfOptions );

   return TRUE;
}

L_INT CDemo::EnumViews(CArray<CDemoView*,CDemoView*>& arrViews)
{
   POSITION DocTemplatePos = GetFirstDocTemplatePosition();
   CDocTemplate* pDocTemplate = GetNextDocTemplate(DocTemplatePos);

   POSITION DocPos = pDocTemplate->GetFirstDocPosition();
  
   arrViews.RemoveAll();
   
   while (DocPos!=NULL)
   {
      CDemoDoc* pDoc = (CDemoDoc*)pDocTemplate->GetNextDoc(DocPos);
      if (!pDoc)
         return FALSE;
      POSITION pos = pDoc->GetFirstViewPosition();
      while (pos != NULL)
      {
         CView* pView = pDoc->GetNextView(pos);
         arrViews.Add((CDemoView*)pView);
      }   
   }
   return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About

class CAboutDlg : public CDialog
{
public:
   CAboutDlg();

// Dialog Data
   //{{AFX_DATA(CAboutDlg)
   enum { IDD = IDD_ABOUTBOX };
   //}}AFX_DATA

   // ClassWizard generated virtual function overrides
   //{{AFX_VIRTUAL(CAboutDlg)
   protected:
   virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
   //}}AFX_VIRTUAL

// Implementation
protected:
   //{{AFX_MSG(CAboutDlg)
   virtual BOOL OnInitDialog();
   //}}AFX_MSG
   DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
   CDialog::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
   //{{AFX_MSG_MAP(CAboutDlg)
   //}}AFX_MSG_MAP
END_MESSAGE_MAP()

// App command to run the dialog
void CDemo::OnAppAbout()
{
   CAboutDlg aboutDlg;
   aboutDlg.DoModal();
}

/////////////////////////////////////////////////////////////////////////////
// CDemo commands

void CDemo::OnEditPaste() 
{
   if(m_LUserBitmap.IsClipboardReady())
   {
      if(m_LUserBitmap.CopyFromClipboard(m_pMainWnd->m_hWnd)==SUCCESS)
         CreateNewBitmapWindow(_T("Paste"),&m_LUserBitmap);  
   }
}

L_BOOL CDemo::m_bOpenMRC = FALSE;
void CDemo::OnUpdateEditPaste(CCmdUI* pCmdUI) 
{
    pCmdUI->Enable(m_LUserBitmap.IsClipboardReady());
}

CDocument* CDemo::OpenDocumentFile(LPCTSTR lpszFileName) 
{
   m_DoucumentMode = DOCUMENT_MODE_FILE;
   return  CWinApp::OpenDocumentFile(lpszFileName); 
}

void CDemo::CreateNewBitmapWindow(LPTSTR lpCaption,LBitmapBase* pLBitmapSrc)
{
   if(pLBitmapSrc==NULL)
   {
      m_LUserBitmap.DisplayError(m_pMainWnd->m_hWnd,_T("Error : Create window"));
      ASSERT(FALSE);
      return ;
   }

   m_DoucumentMode = DOCUMENT_MODE_BITMAP;

   memset(&m_szCaption,0,sizeof(m_szCaption));
   
   m_LUserBitmap.SetHandle(pLBitmapSrc->GetHandle());

   if(lpCaption==NULL)
      _tcscpy(m_szCaption,_T("LEAD Bitmap")); 
   else
      memmove(m_szCaption,lpCaption,min(sizeof(m_szCaption),lstrlen(lpCaption)* sizeof (L_TCHAR))); 

   if(m_LUserBitmap.IsAllocated()==TRUE) 
      OnFileNew();
}

void CDemo::OnFileOpen() 
{
   OPENDLGPARAMS FOParm ;
   OPENFILENAME  OpenFileName;

   memset( &FOParm, 0, sizeof(OPENDLGPARAMS)) ;
   memset( &OpenFileName, 0, sizeof(OPENFILENAME)) ;

   OpenFileName.lStructSize       = sizeof(OPENFILENAME);
   OpenFileName.lpstrInitialDir   = NULL;
   OpenFileName.Flags             = OFN_EXPLORER;
   
   FOParm.uStructSize      = sizeof(OPENDLGPARAMS);
     
   FOParm.uDlgFlags        = DLG_OPEN_SHOW_MULTIPAGE ;
   if (!m_bOpenMRC)
   {
      FOParm.uDlgFlags       |= DLG_OPEN_ENABLESIZING        |
                                DLG_OPEN_USEFILESTAMP        |
                                DLG_OPEN_SHOW_DELPAGE        |
                                DLG_OPEN_SHOW_LOADOPTIONS    |
                                DLG_OPEN_SHOW_FILEINFO       |
                                DLG_OPEN_SHOW_PDFOPTIONS     |
                                DLG_OPEN_SHOW_RASTEROPTIONS  |
                                DLG_OPEN_SHOW_VECTOROPTIONS  |
                                DLG_OPEN_VIEWTOTALPAGES      |
                                DLG_OPEN_SHOW_PDFOPTIONS     |
                                DLG_OPEN_SHOW_LOADOPTIONS    |
                                (m_bLoadCompressed?DLG_OPEN_ALWAYSLOADCOMPRESSED:0) |
                                (m_bLoadRotated?DLG_OPEN_ALWAYSLOADROTATED:0);
   }
   else
   {
      OpenFileName.lStructSize       = sizeof(OPENFILENAME);
      OpenFileName.lpstrFilter       = TEXT("MRC\0")TEXT("*.mrc;*.tif\0");
      OpenFileName.lpstrCustomFilter = NULL;
      OpenFileName.nMaxCustFilter    = 0;
      OpenFileName.nFilterIndex      = 1;
      OpenFileName.lpstrFileTitle    = NULL;
      OpenFileName.nMaxFileTitle     = 0;
      OpenFileName.lpstrInitialDir   = NULL;
      OpenFileName.lpstrTitle        = TEXT("Open MRC");
      OpenFileName.nFileOffset       = 0;
      OpenFileName.nFileExtension    = 0;
      OpenFileName.lpstrDefExt       = NULL;
      OpenFileName.lpfnHook          = NULL;
   }
      
   FOParm.bPreviewEnabled = TRUE;

   m_LUserBitmap.DialogFile()->SetOpenParams(&FOParm) ;
   m_LUserBitmap.DialogFile()->EnablePreview(m_bDlgEnablePreview);
   m_LUserBitmap.DialogFile()->SetOpenFileName(&OpenFileName) ;
   m_LUserBitmap.DialogFile()->EnableCallBack(FALSE);

   L_INT nRetCode = m_LUserBitmap.DialogFile()->DoModalOpen(m_pMainWnd->m_hWnd);

   if(nRetCode==SUCCESS_DLG_OK)
   {
      m_LUserBitmap.DialogFile()->GetOpenParams(&FOParm,sizeof(OPENDLGPARAMS)) ;
      if(FILE_RAS_PDF == FOParm.pFileData[0].FileOptions.nType)
      {
         LFileSettings::SetPDFOptions(&((LPOPENDLGOPTIONS_PDF)FOParm.pFileData[0].FileOptions.pOptions)->PDFOptions);
         if (!m_bIsPdfDpiSet)
         {
            CSize                resolution ( 0, 0);
            PDFCompDPIOptionsDlg DPIDlg ;
            
            resolution.cx = ((LPOPENDLGOPTIONS_PDF)FOParm.pFileData[0].FileOptions.pOptions)->PDFOptions.nXResolution;
            resolution.cy = ((LPOPENDLGOPTIONS_PDF)FOParm.pFileData[0].FileOptions.pOptions)->PDFOptions.nYResolution;
            
            DPIDlg.SetDPIResolution ( resolution ) ;
            
            if ( IDOK == DPIDlg.DoModal ( ) )
            {
               FILEPDFOPTIONS PDFOptions;
               
               ZeroMemory (&PDFOptions, sizeof(FILEPDFOPTIONS));
               
               LFileSettings::GetPDFOptions(&PDFOptions, sizeof(FILEPDFOPTIONS));
               
               resolution = DPIDlg.GetDPIResolution ( ) ;
               
               PDFOptions.nXResolution = resolution.cx;
               PDFOptions.nYResolution = resolution.cy;
               
               LFileSettings::SetPDFOptions(&PDFOptions);
               
               m_bIsPdfDpiSet = TRUE;
            }
         }
      }

      L_TCHAR szFileName[256];
      memset(szFileName,0,sizeof(szFileName));
      L_UINT uSize=sizeof(szFileName);
      m_LUserBitmap.GetFileName(szFileName,&uSize);
      
      m_DoucumentMode = DOCUMENT_MODE_FILE;

      m_LUserBitmap.DialogFile()->GetOpenParams(&FOParm,sizeof(FOParm)) ;

      if ( FOParm.pFileData && FOParm.pFileData[0].pFileInfo != NULL )
      {
         if ( ( FOParm.pFileData[0].pFileInfo->Format == FILE_J2K ) ||
              ( FOParm.pFileData[0].pFileInfo->Format == FILE_JP2 ) ||
              ( FOParm.pFileData[0].pFileInfo->Format == FILE_CMW ) )
         {
            LPOPENDLGOPTIONS_RASTERMISC pOption = ( LPOPENDLGOPTIONS_RASTERMISC ) FOParm.pFileData[0].FileOptions.pOptions ;
            
            LFileSettings::SetLoadResolution ( FOParm.pFileData[0].pFileInfo->Format,pOption->uXResolution,pOption->uYResolution ) ;
         }
      }
      
      POSITION pos = GetFirstDocTemplatePosition();
      CDocTemplate* pDocTemplate = GetNextDocTemplate(pos);
      pDocTemplate->OpenDocumentFile(szFileName);
   }
}

void CDemo::OnFileAllError() 
{
   LBase::DisplayErrorList(m_pMainWnd->m_hWnd);
}

void CDemo::OnFileLastError() 
{
   LBase::DisplayErrorFromList(m_pMainWnd->m_hWnd);
}

void CDemo::OnUpdateFileAllError(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(LBase::GetErrorsNumber());
}

void CDemo::OnUpdateFileLastError(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(LBase::GetErrorsNumber());
}

void CDemo::OnWindowCloseAll() 
{
   CloseAllDocuments(TRUE) ;
}

BOOL CAboutDlg::OnInitDialog() 
{
   CDialog::OnInitDialog();
   
   VERSIONINFO VersionInfo;
   L_TCHAR      szMessage[1024];     

   memset(szMessage,0,sizeof(szMessage));
   LBase::VersionInfo(&VersionInfo, sizeof(VersionInfo));
   wsprintf(szMessage,
            _T("LEAD Product: %hs\r\n%s")
            _T("Version %d.%d\r\n")
            _T("Date: %hs\r\n")
            _T("Time: %hs"),
            (L_CHAR L_FAR *)VersionInfo.Product,
            (L_TCHAR L_FAR *)((VersionInfo.Level==TOOLKIT_LEVEL_MEDICAL) ? _T("Medical editions") : 
                             (VersionInfo.Level==TOOLKIT_LEVEL_DOCUMENT)? _T("Express editions "): _T("Professional Edition")),
            VersionInfo.MajorNumber,VersionInfo.MinorNumber,
            (L_CHAR L_FAR *)VersionInfo.Date,
            (L_CHAR L_FAR *)VersionInfo.Time);

   GetDlgItem(IDC_STATIC_VERSIONINFO)->SetWindowText(szMessage);
   
   return TRUE;  // return TRUE unless you set the focus to a control
                 // EXCEPTION: OCX Property Pages should return FALSE
}

L_BOOL RegisterAppKey ( HINSTANCE hInstance )
{
   DWORD dwDispos ;
   BOOL  fRet = TRUE ;
   LONG  lRet ; 
   HKEY   hKey ;
   L_TCHAR strOpen [MAX_PATH*2] = _T("");
   L_TCHAR strDefaultIcon [MAX_PATH*2] = _T("");
   L_TCHAR* pszPathName = NULL ;
   L_TCHAR L_FAR* szRegisterKey [ REG_KEYS ] = { _T("\\shell\\open\\command"), 
                                                 _T("\\DefaultIcon") } ;

   {// CREATE SERVER NODE
      
      lRet = RegCreateKeyEx ( HKEY_CLASSES_ROOT, REGISTRYKEY_SERVER_NAME, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, &dwDispos ) ;
      RegCloseKey ( hKey ) ;
      
      if ( lRet != ERROR_SUCCESS )
      {
         return FALSE ;
      }
      
   }// CREATE SERVER NODE
   
   {
      L_UINT32 dwRet = 0 ;
      L_TCHAR  szFullFileName [L_MAXPATH] = {0} ;
      L_TCHAR  szShortFileName [L_MAXPATH] = {0} ;      
      
      L_TCHAR L_FAR* szRegisterKeyDefaultValues [ REG_KEYS ] ;
      int k ;


      GetModuleFileName ( hInstance, szFullFileName, MAX_PATH ) ; 
      
      dwRet = GetShortPathName ( szFullFileName, 
                                 szShortFileName,
                                 L_MAXPATH ) ;

      if ( ERROR_INVALID_PARAMETER == dwRet )
      {
         pszPathName = szFullFileName ;
      }
      else
      {
         pszPathName = szShortFileName ;
      }

      // Open STRING   
      wsprintf ( strOpen, _T("%s \"%%1\""), pszPathName ) ;   
      // DEFAULT ICON   
      wsprintf ( strDefaultIcon,_T("%s,%d"), pszPathName, -IDR_MAINFRAME ) ;
      
      szRegisterKeyDefaultValues [ 0 ] = strOpen ;
      szRegisterKeyDefaultValues [ 1 ] = strDefaultIcon ;

      for ( k = 0; k < REG_KEYS; k++ )
      {
         L_TCHAR strKey [ MAX_PATH * 2 ] = { 0 } ;
         
          
         //compose full key
         wsprintf ( strKey, _T("%s%s"), REGISTRYKEY_SERVER_NAME, szRegisterKey [ k ] ) ;
         
         // create...
         lRet = RegCreateKeyEx ( HKEY_CLASSES_ROOT, strKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, &dwDispos ) ;
         
         // set default value
         if ( lRet == ERROR_SUCCESS )
         {
            RegSetValueEx ( hKey, _T(""), 0, REG_SZ, ( BYTE* CONST ) ( szRegisterKeyDefaultValues [ k ] ), ( lstrlen ( szRegisterKeyDefaultValues [ k ] ) + 1 ) * sizeof ( TCHAR ) ) ;
         }
         else
         {
            fRet = FALSE ;
         }
         
         // close key handle
         RegCloseKey ( hKey ) ;
      }
   }
   
   return fRet;
}

void CDemo::OnConvert() 
{
	// TODO: Add your command handler code here
   FILECONVERSIONDLGPARAMS DlgParams;
   memset(&DlgParams,0,sizeof(FILECONVERSIONDLGPARAMS));

   LDialogFile dlg;

   DlgParams.uStructSize           = sizeof ( FILECONVERSIONDLGPARAMS ) ;
   DlgParams.uOverwrite            = DLG_FILECONVERSION_OVERWRITE_SKIP ;
   DlgParams.pFileFormats          = NULL ;
   DlgParams.nFileFormatsCount     = 0 ;
   DlgParams.bUseLogReport         = TRUE ;
   DlgParams.bRemoveSrcFile        = FALSE ;
   DlgParams.bShowFullPath         = TRUE ;
   DlgParams.bUseOriginalFolder    = TRUE ;
   DlgParams.pszSrcFileList        = NULL ;
   DlgParams.uDlgFlags             = DLG_FILECONVERSION_SHOW_LOADOPTIONS    |
                                       DLG_FILECONVERSION_SHOW_FILEINFO       |
                                       DLG_FILECONVERSION_SHOW_PREVIEW_PAGES  |
                                       DLG_FILECONVERSION_SHOW_RESIZE         |
                                       DLG_FILECONVERSION_SHOW_ROTATE         |
                                       DLG_FILECONVERSION_SHOW_NAMINGTEMPLATE |
                                       DLG_FILECONVERSION_SHOW_OVERWRITE      |
                                       DLG_FILECONVERSION_SHOW_OVERWRITE_ALL  |
                                       DLG_FILECONVERSION_SHOW_ADD            |
                                       DLG_FILECONVERSION_SHOW_ADDFOLDER      |
                                       DLG_FILECONVERSION_SHOW_REMOVE         |
                                       DLG_FILECONVERSION_SHOW_SELECTALL      |
                                       DLG_FILECONVERSION_SHOW_DELETEORIGINAL ;
   
   dlg.EnablePreview(theApp.m_bDlgEnablePreview );
   dlg.SetFileConversionParams(&DlgParams);
   dlg.DoModalFileConversion(m_pMainWnd->m_hWnd);
}

int CDemo::ExitInstance()
{
	return CWinApp::ExitInstance();
}


void CDemo::OnFileOpenmrc() 
{
   m_bOpenMRC = TRUE ;
   OnFileOpen();
   m_bOpenMRC = FALSE ;
}