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

#include "stdafx.h"
#include "LTScrCpr.h"

#include "MainFrm.h"
#include "ChildFrm.h"
#include "LTSCDoc.h"
#include "LTSCView.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CLTScrCprApp

BEGIN_MESSAGE_MAP(CLTScrCprApp, CWinApp)
	//{{AFX_MSG_MAP(CLTScrCprApp)

	// Edit menu functions
	ON_COMMAND(IDM_EDIT_PASTE, OnEditPaste)
	ON_UPDATE_COMMAND_UI(IDM_EDIT_PASTE, OnUpdateEditPaste)

	// Capture menu functions
	ON_COMMAND(IDM_CAPTURE_ACTIVEWINDOW, OnCaptureActivewindow)
	ON_COMMAND(IDM_CAPTURE_ACTIVECLIENT, OnCaptureActiveclient)
	ON_COMMAND(IDM_CAPTURE_FULLSCREEN, OnCaptureFullscreen)
	ON_COMMAND(IDM_CAPTURE_SELECTEDOBJECT, OnCaptureSelectedobject)
	ON_COMMAND(IDM_CAPTURE_MENUUNDERCURSOR, OnCaptureMenuundercursor)
	ON_COMMAND(IDM_CAPTURE_SELECTEDAREA, OnCaptureSelectedarea)
	ON_COMMAND(IDM_CAPTURE_WALLPAPER, OnCaptureWallpaper)
	ON_COMMAND(IDM_CAPTURE_MOUSECURSOR, OnCaptureMousecursor)
	ON_COMMAND(IDM_CAPTURE_WINDOWUNDERCURSOR, OnCaptureWindowundercursor)
	ON_COMMAND(IDM_CAPTURE_STOP, OnCaptureStop)
	ON_COMMAND(IDM_CAPTURE_FROMEXEDLGTREE, OnCaptureFromexedlgtree)
	ON_COMMAND(IDM_CAPTURE_FROMEXEDLGTABBEDVIEW, OnCaptureFromexedlgtabbedview)
	ON_UPDATE_COMMAND_UI(IDM_CAPTURE_ACTIVEWINDOW, OnUpdateCaptureActivewindow)
	ON_UPDATE_COMMAND_UI(IDM_CAPTURE_ACTIVECLIENT, OnUpdateCaptureActiveclient)
	ON_UPDATE_COMMAND_UI(IDM_CAPTURE_FULLSCREEN, OnUpdateCaptureFullscreen)
	ON_UPDATE_COMMAND_UI(IDM_CAPTURE_SELECTEDOBJECT, OnUpdateCaptureSelectedobject)
	ON_UPDATE_COMMAND_UI(IDM_CAPTURE_MENUUNDERCURSOR, OnUpdateCaptureMenuundercursor)
	ON_UPDATE_COMMAND_UI(IDM_CAPTURE_SELECTEDAREA, OnUpdateCaptureSelectedarea)
	ON_UPDATE_COMMAND_UI(IDM_CAPTURE_WALLPAPER, OnUpdateCaptureWallpaper)
	ON_UPDATE_COMMAND_UI(IDM_CAPTURE_MOUSECURSOR, OnUpdateCaptureMousecursor)
	ON_UPDATE_COMMAND_UI(IDM_CAPTURE_WINDOWUNDERCURSOR, OnUpdateCaptureWindowundercursor)
	ON_UPDATE_COMMAND_UI(IDM_CAPTURE_STOP, OnUpdateCaptureStop)

	// Option menu functions
	ON_COMMAND(IDM_OPTIONS_OPTIONS, OnOptionsOptions)
	ON_COMMAND(IDM_OPTIONS_AREA, OnOptionsArea)
	ON_COMMAND(IDM_OPTIONS_OBJECT, OnOptionsObject)
	ON_COMMAND(IDM_OPTIONS_MIN, OnOptionsMin)
	ON_COMMAND(IDM_OPTIONS_RESTORE, OnOptionsRestore)
	ON_COMMAND(IDM_OPTIONS_BEEP, OnOptionsBeep)
	ON_UPDATE_COMMAND_UI(IDM_OPTIONS_MIN, OnUpdateOptionsMin)
	ON_UPDATE_COMMAND_UI(IDM_OPTIONS_RESTORE, OnUpdateOptionsRestore)
	ON_UPDATE_COMMAND_UI(IDM_OPTIONS_BEEP, OnUpdateOptionsBeep)

	// Help menu functions
	ON_COMMAND(ID_APP_ABOUT, OnAppAbout)

	//}}AFX_MSG_MAP
	// Standard file based document commands
	ON_COMMAND(ID_FILE_NEW, CWinApp::OnFileNew)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CLTScrCprApp construction

CLTScrCprApp::CLTScrCprApp()
{
	m_bMinimizeOption = TRUE;
	m_bRestoreOption  = TRUE;
	m_bBeepOption     = FALSE;
}

/////////////////////////////////////////////////////////////////////////////
// The one and only CLTScrCprApp object

CLTScrCprApp theApp;

/////////////////////////////////////////////////////////////////////////////
// CLTScrCprApp initialization

BOOL CLTScrCprApp::InitInstance()
{
	AfxEnableControlContainer();

	// 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.
	// TODO: You should modify this string to be something appropriate
	// such as the name of your company or organization.
	SetRegistryKey(_T("Local AppWizard-Generated Applications"));

	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_LTSCRCTYPE,
		RUNTIME_CLASS(CLTScrCprDoc),
		RUNTIME_CLASS(CChildFrame), // custom MDI child frame
		RUNTIME_CLASS(CLTScrCprView));
	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;
	ParseCommandLine(cmdInfo);

	if(cmdInfo.m_nShellCommand == CCommandLineInfo::FileNew)
		cmdInfo.m_nShellCommand = CCommandLineInfo::FileNothing;

	// 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(SW_SHOWMAXIMIZED);
	pMainFrame->UpdateWindow();

	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)
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

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

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

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

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

/////////////////////////////////////////////////////////////////////////////
// CLTScrCprApp message handlers


int CLTScrCprApp::ExitInstance() 
{
	// Free the loaded libs.
   LDialogBase::Free();
	LBase::UnloadLibraries(m_uLoaded);
		
	return CWinApp::ExitInstance();
}

// +++++++++++++++++++++++++++++    EDIT  MENU    +++++++++++++++++++++++++++++

/*+--------------------+
  |  Operation: Paste  |
  +--------------------+*/
void CLTScrCprApp::OnEditPaste() 
{
	// Check if the clipboard already contains an image, the paste it.
   if(m_LUserBmp.IsClipboardReady())
   {
      if(m_LUserBmp.CopyFromClipboard(m_pMainWnd->m_hWnd) == SUCCESS)
         CreateNewCaptureWindow(_T("Paste"), &m_LUserBmp);
   }
}

void CLTScrCprApp::OnUpdateEditPaste(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(m_LUserBmp.IsClipboardReady());
}

// +++++++++++++++++++++++++++++    CAPTURE  MENU    +++++++++++++++++++++++++++++

/*+------------------------------------+
  |  Operation: Capture Active Window  |
  +------------------------------------+*/
void CLTScrCprApp::OnCaptureActivewindow() 
{	
	// Put the current capture type & stop the previous one if there.
	// Check if the minimize option seted.
	// Perform capture & clean the capture type.

	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

	pLUserSC->m_iCaptureType = CAPTURE_ACTIVEWINDOW;

	pLUserSC->StopCapture();

	if(m_bMinimizeOption)
		m_pMainWnd->ShowWindow(SW_MINIMIZE);

	pLUserSC->CaptureActiveWindow();

	pLUserSC->m_iCaptureType = CAPTURE_NONE;
}

void CLTScrCprApp::OnUpdateCaptureActivewindow(CCmdUI* pCmdUI) 
{
	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

   pCmdUI->SetRadio(pLUserSC->m_iCaptureType == CAPTURE_ACTIVEWINDOW);
}

/*+------------------------------------+
  |  Operation: Capture Active Client  |
  +------------------------------------+*/
void CLTScrCprApp::OnCaptureActiveclient() 
{
	// Put the current capture type & stop the previous one if there.
	// Check if the minimize option seted.
	// Perform capture & clean the capture type.

	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

	pLUserSC->m_iCaptureType = CAPTURE_ACTIVECLIENT;

	pLUserSC->StopCapture();

	if(m_bMinimizeOption)
		m_pMainWnd->ShowWindow(SW_MINIMIZE);

	pLUserSC->CaptureActiveClient();

	pLUserSC->m_iCaptureType = CAPTURE_NONE;
}

void CLTScrCprApp::OnUpdateCaptureActiveclient(CCmdUI* pCmdUI) 
{
	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

   pCmdUI->SetRadio(pLUserSC->m_iCaptureType == CAPTURE_ACTIVECLIENT);
}

/*+----------------------------------+
  |  Operation: Capture Full Screen  |
  +----------------------------------+*/
void CLTScrCprApp::OnCaptureFullscreen() 
{
	// Put the current capture type & stop the previous one if there.
	// Check if the minimize option seted.
	// Perform capture & clean the capture type.

	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

	pLUserSC->m_iCaptureType = CAPTURE_FULLSCREEN;

	pLUserSC->StopCapture();

	if(m_bMinimizeOption)
		m_pMainWnd->ShowWindow(SW_MINIMIZE);

	pLUserSC->CaptureFullScreen();

	pLUserSC->m_iCaptureType = CAPTURE_NONE;
}

void CLTScrCprApp::OnUpdateCaptureFullscreen(CCmdUI* pCmdUI) 
{
	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

   pCmdUI->SetRadio(pLUserSC->m_iCaptureType == CAPTURE_FULLSCREEN);
}

/*+--------------------------------------+
  |  Operation: Capture Selected Object  |
  +--------------------------------------+*/
void CLTScrCprApp::OnCaptureSelectedobject() 
{
	// Put the current capture type & stop the previous one if there.
	// Check if the minimize option seted.
	// Perform capture & clean the capture type.

	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

	pLUserSC->m_iCaptureType = CAPTURE_SELECTEDOBJECT;

	pLUserSC->StopCapture();

	if(m_bMinimizeOption)
		m_pMainWnd->ShowWindow(SW_MINIMIZE);

	pLUserSC->CaptureSelectedObject();

	pLUserSC->m_iCaptureType = CAPTURE_NONE;
}

void CLTScrCprApp::OnUpdateCaptureSelectedobject(CCmdUI* pCmdUI) 
{
	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

   pCmdUI->SetRadio(pLUserSC->m_iCaptureType == CAPTURE_SELECTEDOBJECT);
}

/*+----------------------------------------+
  |  Operation: Capture Menu Under Cursor  |
  +----------------------------------------+*/
void CLTScrCprApp::OnCaptureMenuundercursor() 
{
	// Put the current capture type & stop the previous one if there.
	// Check if the minimize option seted.
	// Perform capture & clean the capture type.

	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

	pLUserSC->m_iCaptureType = CAPTURE_MENUUNDERCURSOR;

	pLUserSC->StopCapture();

	if(m_bMinimizeOption)
		m_pMainWnd->ShowWindow(SW_MINIMIZE);

	pLUserSC->CaptureMenuUnderCursor();

	pLUserSC->m_iCaptureType = CAPTURE_NONE;
}

void CLTScrCprApp::OnUpdateCaptureMenuundercursor(CCmdUI* pCmdUI) 
{
	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

   pCmdUI->SetRadio(pLUserSC->m_iCaptureType == CAPTURE_MENUUNDERCURSOR);
}

/*+------------------------------------+
  |  Operation: Capture Selected Area  |
  +------------------------------------+*/
void CLTScrCprApp::OnCaptureSelectedarea() 
{
	// Put the current capture type & stop the previous one if there.
	// Check if the minimize option seted.
	// Perform capture & clean the capture type.

	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

	pLUserSC->m_iCaptureType = CAPTURE_SELECTEDAREA;

	pLUserSC->StopCapture();

	if(m_bMinimizeOption)
		m_pMainWnd->ShowWindow(SW_MINIMIZE);

	pLUserSC->CaptureArea();

	pLUserSC->m_iCaptureType = CAPTURE_NONE;
}

void CLTScrCprApp::OnUpdateCaptureSelectedarea(CCmdUI* pCmdUI) 
{
	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

   pCmdUI->SetRadio(pLUserSC->m_iCaptureType == CAPTURE_SELECTEDAREA);
}

/*+--------------------------------+
  |  Operation: Capture Wallpaper  |
  +--------------------------------+*/
void CLTScrCprApp::OnCaptureWallpaper() 
{
	// Put the current capture type & stop the previous one if there.
	// Check if the minimize option seted.
	// Perform capture & clean the capture type.

	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

	pLUserSC->m_iCaptureType = CAPTURE_WALLPAPER;

	pLUserSC->StopCapture();

	if(m_bMinimizeOption)
		m_pMainWnd->ShowWindow(SW_MINIMIZE);

	pLUserSC->CaptureWallpaper();

	pLUserSC->m_iCaptureType = CAPTURE_NONE;
}

void CLTScrCprApp::OnUpdateCaptureWallpaper(CCmdUI* pCmdUI) 
{
	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

   pCmdUI->SetRadio(pLUserSC->m_iCaptureType == CAPTURE_WALLPAPER);
}

/*+-----------------------------------+
  |  Operation: Capture Mouse Cursor  |
  +-----------------------------------+*/
void CLTScrCprApp::OnCaptureMousecursor() 
{
	// Put the current capture type & stop the previous one if there.
	// Check if the minimize option seted.
	// Perform capture & clean the capture type.

	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

	pLUserSC->m_iCaptureType = CAPTURE_MOUSECURSOR;

	pLUserSC->StopCapture();

	if(m_bMinimizeOption)
		m_pMainWnd->ShowWindow(SW_MINIMIZE);

	pLUserSC->CaptureMouseCursor();

	pLUserSC->m_iCaptureType = CAPTURE_NONE;
}

void CLTScrCprApp::OnUpdateCaptureMousecursor(CCmdUI* pCmdUI) 
{
	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

   pCmdUI->SetRadio(pLUserSC->m_iCaptureType == CAPTURE_MOUSECURSOR);
}

/*+------------------------------------------+
  |  Operation: Capture Window Under Cursor  |
  +------------------------------------------+*/
void CLTScrCprApp::OnCaptureWindowundercursor() 
{
	// Put the current capture type & stop the previous one if there.
	// Check if the minimize option seted.
	// Perform capture & clean the capture type.

	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

	pLUserSC->m_iCaptureType = CAPTURE_WINDOWUNDERCURSOR;

	pLUserSC->StopCapture();

	if(m_bMinimizeOption)
		m_pMainWnd->ShowWindow(SW_MINIMIZE);

	pLUserSC->CaptureWindowUnderCursor();

	pLUserSC->m_iCaptureType = CAPTURE_NONE;
}

void CLTScrCprApp::OnUpdateCaptureWindowundercursor(CCmdUI* pCmdUI) 
{
	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

   pCmdUI->SetRadio(pLUserSC->m_iCaptureType == CAPTURE_WINDOWUNDERCURSOR);
}

/*+---------------------------+
  |  Operation: Stop Capture  |
  +---------------------------+*/
void CLTScrCprApp::OnCaptureStop() 
{
	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

	pLUserSC->StopCapture();

	pLUserSC->m_iCaptureType = CAPTURE_NONE;
}

void CLTScrCprApp::OnUpdateCaptureStop(CCmdUI* pCmdUI) 
{
	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

   pCmdUI->Enable(pLUserSC->m_iCaptureType != CAPTURE_NONE);
}

/*+----------------------------------------+
  |  Operation: Capture From Exe Dlg Tree  |
  +----------------------------------------+*/
void CLTScrCprApp::OnCaptureFromexedlgtree() 
{
	// Put the current capture type & stop the previous one if there.
	// Check if the minimize option seted.
	// Perform capture & clean the capture type.

	COLORREF TransparentColor = RGB(0,0,0);

	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

	pLUserSC->m_iCaptureType = CAPTURE_FROMEXEDLGTREE;

	pLUserSC->StopCapture();

   L_BOOL bRetCode = pLUserSC->EnableCallBack(TRUE);

	pLUserSC->CaptureFromEXEDlg(0,
										 &TransparentColor,
										 RESTYPE_BITMAP | RESTYPE_ICON | RESTYPE_CURSOR,
                               0,
										 LTCAPDLG_TREEVIEW);

	pLUserSC->m_iCaptureType = CAPTURE_NONE;

   pLUserSC->EnableCallBack(bRetCode);
}

/*+-----------------------------------------------+
  |  Operation: Capture From Exe Dlg Tabbed View  |
  +-----------------------------------------------+*/
void CLTScrCprApp::OnCaptureFromexedlgtabbedview() 
{
	// Put the current capture type & stop the previous one if there.
	// Check if the minimize option seted.
	// Perform capture & clean the capture type.

	COLORREF TransparentColor = RGB(0,0,0);

	LUserScreenCapture* pLUserSC = (LUserScreenCapture*)m_LUserBmp.ScreenCapture();

	pLUserSC->m_iCaptureType = CAPTURE_FROMEXEDLGTABBEDVIEW;

	pLUserSC->StopCapture();

   L_BOOL bRetCode = pLUserSC->EnableCallBack(TRUE);

	pLUserSC->CaptureFromEXEDlg(0,
										 &TransparentColor,
										 RESTYPE_BITMAP | RESTYPE_ICON | RESTYPE_CURSOR,
                               0,
										 LTCAPDLG_TABVIEW);

	pLUserSC->m_iCaptureType = CAPTURE_NONE;

   pLUserSC->EnableCallBack(bRetCode);

}

// +++++++++++++++++++++++++++++    OPTION  MENU    +++++++++++++++++++++++++++++

/*+----------------------------+
  |  Operation: Option Dialog  |
  +----------------------------+*/
void CLTScrCprApp::OnOptionsOptions() 
{
	// Call the capture option dlg.
   L_BOOL bEnable = m_LUserBmp.ScreenCapture()->EnableCallBack(FALSE);
	m_LUserBmp.ScreenCapture()->SetCaptureOptionDlg(m_pMainWnd->m_hWnd, 0);
   m_LUserBmp.ScreenCapture()->EnableCallBack(bEnable );
   m_LUserBmp.ScreenCapture()->EnableCallBack(bEnable);
}

/*+---------------------------------+
  |  Operation: Option Area Dialog  |
  +---------------------------------+*/
void CLTScrCprApp::OnOptionsArea() 
{
	// Call the capture area option dlg.
   L_BOOL bEnable = m_LUserBmp.ScreenCapture()->EnableCallBack(FALSE);
	m_LUserBmp.ScreenCapture()->CaptureAreaOptionDlg(m_pMainWnd->m_hWnd , 0);
   m_LUserBmp.ScreenCapture()->EnableCallBack(bEnable );
}

/*+-----------------------------------+
  |  Operation: Option Object Dialog  |
  +-----------------------------------+*/
void CLTScrCprApp::OnOptionsObject() 
{
	// Call the capture object option dlg.
   L_BOOL bEnable = m_LUserBmp.ScreenCapture()->EnableCallBack(FALSE);
	m_LUserBmp.ScreenCapture()->CaptureObjectOptionDlg(m_pMainWnd->m_hWnd, 0);
   m_LUserBmp.ScreenCapture()->EnableCallBack(bEnable );
}

/*+-----------------------+
  |  Operation: Minimize  |
  +-----------------------+*/
void CLTScrCprApp::OnOptionsMin() 
{
	m_bMinimizeOption = !m_bMinimizeOption;
}

void CLTScrCprApp::OnUpdateOptionsMin(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck(m_bMinimizeOption);
}

/*+----------------------+
  |  Operation: Restore  |
  +----------------------+*/
void CLTScrCprApp::OnOptionsRestore() 
{
	m_bRestoreOption = !m_bRestoreOption;
}

void CLTScrCprApp::OnUpdateOptionsRestore(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck(m_bRestoreOption);
}

/*+-------------------+
  |  Operation: Beep  |
  +-------------------+*/
void CLTScrCprApp::OnOptionsBeep() 
{
	m_bBeepOption = !m_bBeepOption;
}

void CLTScrCprApp::OnUpdateOptionsBeep(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck(m_bBeepOption);
}

/*+----------------------------------------------------+
  |  Operation : Create New Capture Window             |
  |																	 |
  |  Parameter : lpCaption (Window title bar caption)  |
  |				  pLBitmapSrc (Bitmap handle)				 |
  +----------------------------------------------------+*/
void CLTScrCprApp::CreateNewCaptureWindow(LPTSTR lpCaption, LBitmapBase* pLBitmapSrc)
{
	// Check if bitmap not NULL
   if(pLBitmapSrc == NULL)
   {
      m_LUserBmp.DisplayError(m_pMainWnd->m_hWnd, _T("Can't create a window"));

      return;
   }

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

	if(lpCaption == NULL)
      lstrcpy(m_szCaption,_T("LEAD Bitmap"));

   else
      memmove(m_szCaption, lpCaption, min(sizeof(m_szCaption), lstrlen(lpCaption)* sizeof (L_TCHAR))); 

   if(m_LUserBmp.IsAllocated()) 
      OnFileNew();
}

BOOL CLTScrCprApp::InitApplication() 
{
	// Load LEADTOOLS wrapper .DLLs files
	m_uLoaded = LBase::LoadLibraries(LT_SCR | LT_KRN | LT_DIS | LT_DLG);

	// Check if libraries successfull loaded.
	if(m_uLoaded != LT_SCR + LT_KRN + LT_DIS + LT_DLG)
	{
		LBase::DisplayError(m_pMainWnd->GetSafeHwnd(), _T("Can't load Screen Capture library files"));

		return FALSE;
	}

	// Support GIF, JBIG, & TIF images formats
   WRPUNLOCKSUPPORT();
   LDialogBase::Initialize(DLG_INIT_COLOR);
	return CWinApp::InitApplication();
}