void CBCGPOrganizerApp::UpdateGantt (BOOL bUpdateGantt /*= TRUE*/)
{
CMainFrame* pFrame = (CMainFrame*) AfxGetMainWnd ();
ASSERT_VALID (pFrame);
if (bUpdateGantt)
{
CBCGPOrganizerDoc* pDoc = (CBCGPOrganizerDoc*)
pFrame->GetActiveDocument ();
if (pDoc != NULL)
{
ASSERT_VALID (pDoc);
pDoc->UpdateGantt (m_OptionsGantt);
}
pFrame->UpdateCalendar ();
}
else
{
//DR:
//pFrame->GetPropBar ().Update ();
}
//------------------------
// Set tooltip parameters:
//------------------------
CBCGPToolTipParams params;
params.m_bVislManagerTheme = TRUE;
globalData.m_nMaxToolTipWidth = 150;
GetTooltipManager ()->SetTooltipParams (
BCGP_TOOLTIP_TYPE_GANTT,
m_OptionsGantt.m_ShowToolTip == 2 ?
RUNTIME_CLASS (CPlannerTooltipCtrl) :
RUNTIME_CLASS (CBCGPToolTipCtrl),
¶ms);
}
BOOL CBCGPGanttDemoApp::InitInstance()
{
// Initialize OLE libraries
if (!AfxOleInit())
{
AfxMessageBox(IDP_OLE_INIT_FAILED);
return FALSE;
}
AfxEnableControlContainer();
// 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.
#ifndef _BCGPGANTT_STANDALONE
SetRegistryKey(_T("BCGSoft\\BCGControlBarPro\\Examples"));
#else
SetRegistryKey(_T("BCGSoft\\BCGGantt\\Samples"));
#endif
LoadStdProfileSettings(); // Load standard INI file options (including MRU)
#ifndef _BCGPGANTT_STANDALONE
SetRegistryBase (_T("Settings"));
#endif
#ifndef _BCGPGANTT_STANDALONE
// Initialize all Managers for usage. They are automatically constructed
// if not yet present
InitContextMenuManager();
InitKeyboardManager();
InitTooltipManager();
CBCGPToolTipParams params;
params.m_bVislManagerTheme = TRUE;
globalData.m_nMaxToolTipWidth = 150;
GetTooltipManager ()->SetTooltipParams (
0xFFFF,
RUNTIME_CLASS (CBCGPToolTipCtrl),
¶ms);
#endif
// Register the application's document templates. Document templates
// serve as the connection between documents, frame windows and views.
CSingleDocTemplate* pDocTemplate;
pDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
RUNTIME_CLASS(CBCGPGanttDemoDoc),
RUNTIME_CLASS(CMainFrame), // main SDI frame window
RUNTIME_CLASS(CBCGPGanttDemoView));
AddDocTemplate(pDocTemplate);
// Parse command line for standard shell commands, DDE, file open
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
// Dispatch commands specified on the command line
if (!ProcessShellCommand(cmdInfo))
return FALSE;
// The one and only window has been initialized, so show and update it.
m_pMainWnd->ShowWindow(SW_SHOW);
m_pMainWnd->UpdateWindow();
return TRUE;
}
BOOL CBCGPOrganizerApp::InitInstance()
{
// Initialize OLE libraries
if (!AfxOleInit())
{
AfxMessageBox(IDP_OLE_INIT_FAILED);
return FALSE;
}
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.
#if _MSC_VER < 1400
#ifdef _AFXDLL
Enable3dControls(); // Call this when using MFC in a shared DLL
#else
Enable3dControlsStatic(); // Call this when linking to MFC statically
#endif
#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("BCGSoft\\BCGControlBarPro\\Examples"));
LoadStdProfileSettings(0); // Load standard INI file options (including MRU)
SetRegistryBase (_T("Settings2"));
m_OptionsPlanner.Load ();
m_OptionsGantt.Load ();
// Initialize all Managers for usage. They are automatically constructed
// if not yet present
InitContextMenuManager();
InitKeyboardManager();
InitTooltipManager();
m_bShowFloaty = GetInt (_T("ShowFloaty"), TRUE);
m_nAppLook = GetInt (_T("ApplicationLook"), 1);
m_bShowToolTips = GetInt (_T("ShowToolTips"), TRUE);
m_bShowKeyTips = GetInt (_T("ShowKeyTips"), TRUE);
m_bShowToolTipDescr = GetInt (_T("ShowToolTipDescription"), TRUE);
CBCGPToolTipParams params;
params.m_bVislManagerTheme = TRUE;
globalData.m_nMaxToolTipWidth = 150;
theApp.GetTooltipManager ()->SetTooltipParams (
0xFFFF,
RUNTIME_CLASS (CRibbonTooltipCtrl),
¶ms);
if (m_OptionsPlanner.m_ShowToolTip == 2)
{
GetTooltipManager ()->SetTooltipParams (
BCGP_TOOLTIP_TYPE_PLANNER,
RUNTIME_CLASS (CPlannerTooltipCtrl),
¶ms);
}
if (m_OptionsGantt.m_ShowToolTip == 2)
{
GetTooltipManager ()->SetTooltipParams (
BCGP_TOOLTIP_TYPE_GANTT,
RUNTIME_CLASS (CGanttTooltipCtrl),
¶ms);
}
// Register the application's document templates. Document templates
// serve as the connection between documents, frame windows and views.
CSingleDocTemplate* pDocTemplate;
pDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
RUNTIME_CLASS(CBCGPOrganizerDoc),
RUNTIME_CLASS(CMainFrame), // main SDI frame window
RUNTIME_CLASS(CBCGPOrganizerView));
AddDocTemplate(pDocTemplate);
// Parse command line for standard shell commands, DDE, file open
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
// Dispatch commands specified on the command line
if (!ProcessShellCommand(cmdInfo))
return FALSE;
// The one and only window has been initialized, so show and update it.
m_pMainWnd->ShowWindow(SW_SHOW);
/*
CRect rect;
m_pMainWnd->GetWindowRect (rect);
m_pMainWnd->SetWindowPos (NULL, -1, -1, rect.Width (), rect.Height (), SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
*/
m_pMainWnd->UpdateWindow();
return TRUE;
}
// CTortoiseMergeApp initialization
BOOL CTortoiseMergeApp::InitInstance()
{
SetDllDirectory(L"");
SetTaskIDPerUUID();
CCrashReport::Instance().AddUserInfoToReport(L"CommandLine", GetCommandLine());
{
DWORD len = GetCurrentDirectory(0, NULL);
if (len)
{
std::unique_ptr<TCHAR[]> originalCurrentDirectory(new TCHAR[len]);
if (GetCurrentDirectory(len, originalCurrentDirectory.get()))
{
sOrigCWD = originalCurrentDirectory.get();
sOrigCWD = CPathUtils::GetLongPathname(sOrigCWD);
}
}
}
//set the resource dll for the required language
CRegDWORD loc = CRegDWORD(_T("Software\\TortoiseGit\\LanguageID"), 1033);
long langId = loc;
CString langDll;
HINSTANCE hInst = NULL;
do
{
langDll.Format(_T("%sLanguages\\TortoiseMerge%ld.dll"), (LPCTSTR)CPathUtils::GetAppParentDirectory(), langId);
hInst = LoadLibrary(langDll);
CString sVer = _T(STRPRODUCTVER);
CString sFileVer = CPathUtils::GetVersionFromFile(langDll);
if (sFileVer.Compare(sVer)!=0)
{
FreeLibrary(hInst);
hInst = NULL;
}
if (hInst != NULL)
AfxSetResourceHandle(hInst);
else
{
DWORD lid = SUBLANGID(langId);
lid--;
if (lid > 0)
{
langId = MAKELANGID(PRIMARYLANGID(langId), lid);
}
else
langId = 0;
}
} while ((hInst == NULL) && (langId != 0));
TCHAR buf[6] = { 0 };
_tcscpy_s(buf, _T("en"));
langId = loc;
CString sHelppath = CPathUtils::GetAppDirectory() + _T("TortoiseMerge_en.chm");
free((void*)m_pszHelpFilePath);
m_pszHelpFilePath=_tcsdup(sHelppath);
sHelppath = CPathUtils::GetAppParentDirectory() + _T("Languages\\TortoiseMerge_en.chm");
do
{
GetLocaleInfo(MAKELCID(langId, SORT_DEFAULT), LOCALE_SISO639LANGNAME, buf, _countof(buf));
CString sLang = _T("_");
sLang += buf;
sHelppath.Replace(_T("_en"), sLang);
if (PathFileExists(sHelppath))
{
free((void*)m_pszHelpFilePath);
m_pszHelpFilePath=_tcsdup(sHelppath);
break;
}
sHelppath.Replace(sLang, _T("_en"));
GetLocaleInfo(MAKELCID(langId, SORT_DEFAULT), LOCALE_SISO3166CTRYNAME, buf, _countof(buf));
sLang += _T("_");
sLang += buf;
sHelppath.Replace(_T("_en"), sLang);
if (PathFileExists(sHelppath))
{
free((void*)m_pszHelpFilePath);
m_pszHelpFilePath=_tcsdup(sHelppath);
break;
}
sHelppath.Replace(sLang, _T("_en"));
DWORD lid = SUBLANGID(langId);
lid--;
if (lid > 0)
{
langId = MAKELANGID(PRIMARYLANGID(langId), lid);
}
else
langId = 0;
} while (langId);
setlocale(LC_ALL, "");
// We need to explicitly set the thread locale to the system default one to avoid possible problems with saving files in its original codepage
// The problems occures when the language of OS differs from the regional settings
// See the details here: http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=100887
SetThreadLocale(LOCALE_SYSTEM_DEFAULT);
// InitCommonControls() is required on Windows XP if an application
// manifest specifies use of ComCtl32.dll version 6 or later to enable
// visual styles. Otherwise, any window creation will fail.
InitCommonControls();
CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows));
CMFCButton::EnableWindowsTheming();
EnableTaskbarInteraction(FALSE);
// Initialize all Managers for usage. They are automatically constructed
// if not yet present
InitContextMenuManager();
InitKeyboardManager();
InitTooltipManager ();
CMFCToolTipInfo params;
params.m_bVislManagerTheme = TRUE;
GetTooltipManager ()->SetTooltipParams (
AFX_TOOLTIP_TYPE_ALL,
RUNTIME_CLASS (CMFCToolTipCtrl),
¶ms);
CCmdLineParser parser = CCmdLineParser(this->m_lpCmdLine);
g_sGroupingUUID = parser.GetVal(L"groupuuid");
if (parser.HasKey(_T("?")) || parser.HasKey(_T("help")))
{
CString sHelpText;
sHelpText.LoadString(IDS_COMMANDLINEHELP);
MessageBox(NULL, sHelpText, _T("TortoiseGitMerge"), MB_ICONINFORMATION);
return FALSE;
}
// Initialize OLE libraries
if (!AfxOleInit())
{
AfxMessageBox(IDP_OLE_INIT_FAILED);
return FALSE;
}
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
// Change the registry key under which our settings are stored
SetRegistryKey(_T("TortoiseGitMerge"));
if (CRegDWORD(_T("Software\\TortoiseGitMerge\\Debug"), FALSE)==TRUE)
AfxMessageBox(AfxGetApp()->m_lpCmdLine, MB_OK | MB_ICONINFORMATION);
// To create the main window, this code creates a new frame window
// object and then sets it as the application's main window object
CMainFrame* pFrame = new CMainFrame;
if (pFrame == NULL)
return FALSE;
m_pMainWnd = pFrame;
// create and load the frame with its resources
if (!pFrame->LoadFrame(IDR_MAINFRAME, WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE, NULL, NULL))
return FALSE;
// Fill in the command line options
pFrame->m_Data.m_baseFile.SetFileName(parser.GetVal(_T("base")));
pFrame->m_Data.m_baseFile.SetDescriptiveName(parser.GetVal(_T("basename")));
pFrame->m_Data.m_baseFile.SetReflectedName(parser.GetVal(_T("basereflectedname")));
pFrame->m_Data.m_theirFile.SetFileName(parser.GetVal(_T("theirs")));
pFrame->m_Data.m_theirFile.SetDescriptiveName(parser.GetVal(_T("theirsname")));
pFrame->m_Data.m_theirFile.SetReflectedName(parser.GetVal(_T("theirsreflectedname")));
pFrame->m_Data.m_yourFile.SetFileName(parser.GetVal(_T("mine")));
pFrame->m_Data.m_yourFile.SetDescriptiveName(parser.GetVal(_T("minename")));
pFrame->m_Data.m_yourFile.SetReflectedName(parser.GetVal(_T("minereflectedname")));
pFrame->m_Data.m_mergedFile.SetFileName(parser.GetVal(_T("merged")));
pFrame->m_Data.m_mergedFile.SetDescriptiveName(parser.GetVal(_T("mergedname")));
pFrame->m_Data.m_mergedFile.SetReflectedName(parser.GetVal(_T("mergedreflectedname")));
pFrame->m_Data.m_sPatchPath = parser.HasVal(_T("patchpath")) ? parser.GetVal(_T("patchpath")) : _T("");
pFrame->m_Data.m_sPatchPath.Replace('/', '\\');
if (parser.HasKey(_T("patchoriginal")))
pFrame->m_Data.m_sPatchOriginal = parser.GetVal(_T("patchoriginal"));
if (parser.HasKey(_T("patchpatched")))
pFrame->m_Data.m_sPatchPatched = parser.GetVal(_T("patchpatched"));
pFrame->m_Data.m_sDiffFile = parser.GetVal(_T("diff"));
pFrame->m_Data.m_sDiffFile.Replace('/', '\\');
if (parser.HasKey(_T("oneway")))
pFrame->m_bOneWay = TRUE;
if (parser.HasKey(_T("diff")))
pFrame->m_bOneWay = FALSE;
if (parser.HasKey(_T("reversedpatch")))
pFrame->m_bReversedPatch = TRUE;
if (parser.HasKey(_T("saverequired")))
pFrame->m_bSaveRequired = true;
if (parser.HasKey(_T("saverequiredonconflicts")))
pFrame->m_bSaveRequiredOnConflicts = true;
if (parser.HasKey(_T("deletebasetheirsmineonclose")))
pFrame->m_bDeleteBaseTheirsMineOnClose = true;
if (pFrame->m_Data.IsBaseFileInUse() && !pFrame->m_Data.IsYourFileInUse() && pFrame->m_Data.IsTheirFileInUse())
{
pFrame->m_Data.m_yourFile.TransferDetailsFrom(pFrame->m_Data.m_theirFile);
}
if ((!parser.HasKey(_T("patchpath")))&&(parser.HasVal(_T("diff"))))
{
// a patchfile was given, but not folder path to apply the patch to
// If the patchfile is located inside a working copy, then use the parent directory
// of the patchfile as the target directory, otherwise ask the user for a path.
if (parser.HasKey(_T("wc")))
pFrame->m_Data.m_sPatchPath = pFrame->m_Data.m_sDiffFile.Left(pFrame->m_Data.m_sDiffFile.ReverseFind('\\'));
else
{
CBrowseFolder fbrowser;
fbrowser.m_style = BIF_EDITBOX | BIF_NEWDIALOGSTYLE | BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS;
if (fbrowser.Show(NULL, pFrame->m_Data.m_sPatchPath)==CBrowseFolder::CANCEL)
return FALSE;
}
}
if ((parser.HasKey(_T("patchpath")))&&(!parser.HasVal(_T("diff"))))
{
// A path was given for applying a patchfile, but
// the patchfile itself was not.
// So ask the user for that patchfile
HRESULT hr;
// Create a new common save file dialog
CComPtr<IFileOpenDialog> pfd = NULL;
hr = pfd.CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER);
if (SUCCEEDED(hr))
{
// Set the dialog options
DWORD dwOptions;
if (SUCCEEDED(hr = pfd->GetOptions(&dwOptions)))
{
hr = pfd->SetOptions(dwOptions | FOS_FILEMUSTEXIST | FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST);
}
// Set a title
if (SUCCEEDED(hr))
{
CString temp;
temp.LoadString(IDS_OPENDIFFFILETITLE);
pfd->SetTitle(temp);
}
CSelectFileFilter fileFilter(IDS_PATCHFILEFILTER);
hr = pfd->SetFileTypes(fileFilter.GetCount(), fileFilter);
bool bAdvised = false;
DWORD dwCookie = 0;
CComObjectStackEx<PatchOpenDlgEventHandler> cbk;
CComQIPtr<IFileDialogEvents> pEvents = cbk.GetUnknown();
{
CComPtr<IFileDialogCustomize> pfdCustomize;
hr = pfd->QueryInterface(IID_PPV_ARGS(&pfdCustomize));
if (SUCCEEDED(hr))
{
// check if there's a unified diff on the clipboard and
// add a button to the fileopen dialog if there is.
UINT cFormat = RegisterClipboardFormat(_T("TSVN_UNIFIEDDIFF"));
if ((cFormat)&&(OpenClipboard(NULL)))
{
HGLOBAL hglb = GetClipboardData(cFormat);
if (hglb)
{
pfdCustomize->AddPushButton(101, CString(MAKEINTRESOURCE(IDS_PATCH_COPYFROMCLIPBOARD)));
hr = pfd->Advise(pEvents, &dwCookie);
bAdvised = SUCCEEDED(hr);
}
CloseClipboard();
}
}
}
// Show the save file dialog
if (SUCCEEDED(hr) && SUCCEEDED(hr = pfd->Show(pFrame->m_hWnd)))
{
// Get the selection from the user
CComPtr<IShellItem> psiResult = NULL;
hr = pfd->GetResult(&psiResult);
if (bAdvised)
pfd->Unadvise(dwCookie);
if (SUCCEEDED(hr))
{
PWSTR pszPath = NULL;
hr = psiResult->GetDisplayName(SIGDN_FILESYSPATH, &pszPath);
if (SUCCEEDED(hr))
{
pFrame->m_Data.m_sDiffFile = pszPath;
CoTaskMemFree(pszPath);
}
}
else
{
// no result, which means we closed the dialog in our button handler
std::wstring sTempFile;
if (TrySavePatchFromClipboard(sTempFile))
pFrame->m_Data.m_sDiffFile = sTempFile.c_str();
}
}
else
{
if (bAdvised)
pfd->Unadvise(dwCookie);
return FALSE;
}
}
else
{
OPENFILENAME ofn = {0}; // common dialog box structure
TCHAR szFile[MAX_PATH] = {0}; // buffer for file name
// Initialize OPENFILENAME
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = pFrame->m_hWnd;
ofn.lpstrFile = szFile;
ofn.nMaxFile = _countof(szFile);
CString temp;
temp.LoadString(IDS_OPENDIFFFILETITLE);
if (temp.IsEmpty())
ofn.lpstrTitle = NULL;
else
ofn.lpstrTitle = temp;
ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_EXPLORER;
if( HasClipboardPatch() ) {
ofn.Flags |= ( OFN_ENABLETEMPLATE | OFN_ENABLEHOOK );
ofn.hInstance = AfxGetResourceHandle();
ofn.lpTemplateName = MAKEINTRESOURCE(IDD_PATCH_FILE_OPEN_CUSTOM);
ofn.lpfnHook = CreatePatchFileOpenHook;
}
CSelectFileFilter fileFilter(IDS_PATCHFILEFILTER);
ofn.lpstrFilter = fileFilter;
ofn.nFilterIndex = 1;
// Display the Open dialog box.
if (GetOpenFileName(&ofn)==FALSE)
{
return FALSE;
}
pFrame->m_Data.m_sDiffFile = ofn.lpstrFile;
}
}
if ( pFrame->m_Data.m_baseFile.GetFilename().IsEmpty() && pFrame->m_Data.m_yourFile.GetFilename().IsEmpty() )
{
int nArgs;
LPWSTR *szArglist = CommandLineToArgvW(GetCommandLineW(), &nArgs);
if( NULL == szArglist )
{
TRACE("CommandLineToArgvW failed\n");
}
else
{
if ( nArgs==3 || nArgs==4 )
{
// Four parameters:
// [0]: Program name
// [1]: BASE file
// [2]: my file
// [3]: THEIR file (optional)
// This is the same format CAppUtils::StartExtDiff
// uses if %base and %mine are not set and most
// other diff tools use it too.
if ( PathFileExists(szArglist[1]) && PathFileExists(szArglist[2]) )
{
pFrame->m_Data.m_baseFile.SetFileName(szArglist[1]);
pFrame->m_Data.m_yourFile.SetFileName(szArglist[2]);
if ( nArgs == 4 && PathFileExists(szArglist[3]) )
{
pFrame->m_Data.m_theirFile.SetFileName(szArglist[3]);
}
}
}
else if (nArgs == 2)
{
// only one path specified: use it to fill the "open" dialog
if (PathFileExists(szArglist[1]))
{
pFrame->m_Data.m_yourFile.SetFileName(szArglist[1]);
pFrame->m_Data.m_yourFile.StoreFileAttributes();
}
}
}
// Free memory allocated for CommandLineToArgvW arguments.
LocalFree(szArglist);
}
pFrame->m_bReadOnly = !!parser.HasKey(_T("readonly"));
if (GetFileAttributes(pFrame->m_Data.m_yourFile.GetFilename()) & FILE_ATTRIBUTE_READONLY)
pFrame->m_bReadOnly = true;
pFrame->m_bBlame = !!parser.HasKey(_T("blame"));
// diffing a blame means no editing!
if (pFrame->m_bBlame)
pFrame->m_bReadOnly = true;
pFrame->SetWindowTitle();
if (parser.HasKey(_T("createunifieddiff")))
{
// user requested to create a unified diff file
CString origFile = parser.GetVal(_T("origfile"));
CString modifiedFile = parser.GetVal(_T("modifiedfile"));
if (!origFile.IsEmpty() && !modifiedFile.IsEmpty())
{
CString outfile = parser.GetVal(_T("outfile"));
if (outfile.IsEmpty())
{
CCommonAppUtils::FileOpenSave(outfile, NULL, IDS_SAVEASTITLE, IDS_COMMONFILEFILTER, false, NULL);
}
if (!outfile.IsEmpty())
{
CRegStdDWORD regContextLines(L"Software\\TortoiseGitMerge\\ContextLines", (DWORD)-1);
CAppUtils::CreateUnifiedDiff(origFile, modifiedFile, outfile, regContextLines, false);
return FALSE;
}
}
}
pFrame->resolveMsgWnd = parser.HasVal(L"resolvemsghwnd") ? (HWND)parser.GetLongLongVal(L"resolvemsghwnd") : 0;
pFrame->resolveMsgWParam = parser.HasVal(L"resolvemsgwparam") ? (WPARAM)parser.GetLongLongVal(L"resolvemsgwparam") : 0;
pFrame->resolveMsgLParam = parser.HasVal(L"resolvemsglparam") ? (LPARAM)parser.GetLongLongVal(L"resolvemsglparam") : 0;
// The one and only window has been initialized, so show and update it
pFrame->ActivateFrame();
pFrame->ShowWindow(SW_SHOW);
pFrame->UpdateWindow();
pFrame->ShowDiffBar(!pFrame->m_bOneWay);
if (!pFrame->m_Data.IsBaseFileInUse() && pFrame->m_Data.m_sPatchPath.IsEmpty() && pFrame->m_Data.m_sDiffFile.IsEmpty())
{
pFrame->OnFileOpen(pFrame->m_Data.m_yourFile.InUse());
return TRUE;
}
int line = -2;
if (parser.HasVal(_T("line")))
{
line = parser.GetLongVal(_T("line"));
line--; // we need the index
}
return pFrame->LoadViews(line);
}
BOOL COngTVApp::InitInstance()
{
// customisation des barres d'outils non autorisée
CMFCToolBar::SetCustomizeMode(FALSE);
#ifdef SCINTILLA_DLL
// Chargement de la DLL Scintilla : on va la chercher dans le repertoire de l'exe et nul part ailleurs
// recuperation du path de l'exe
char lpFilename[255];
memset(lpFilename,0,255);
GetModuleFileName(NULL ,lpFilename, 255);
std::string strSciLexerDllName = CPathMgr::ExtractPath(lpFilename);
strSciLexerDllName = strSciLexerDllName + "\\SciLexer.dll";
m_hSciDLL = LoadLibrary(strSciLexerDllName.c_str());
if (NULL == m_hSciDLL)
{
// DLL scintilla non disponible => on ne pourra pas editer de scrip LUA
}
else
{
CVersion versionSciDLL(strSciLexerDllName);
if (versionSciDLL.GetProductVersion() < std::string(EXPECTED_SCINTILLA_VERSION))
{
// version de la DLL inferieur a la version attendue => on ne pourra pas editer de scrip LUA
FreeLibrary(m_hSciDLL);
m_hSciDLL = NULL;
std::string strMsgError = "Dll min expected version : "EXPECTED_SCINTILLA_VERSION" obtained : ";
strMsgError += versionSciDLL.GetProductVersion();
MessageBox(NULL, strMsgError.c_str(), "Unable to load SciLexer.dll", MB_ICONEXCLAMATION);
}
}
#endif
#ifdef TEST_ENGLISH
// Pour forcer une langue
::SetThreadLocale(MAKELCID(MAKELANGID(LANG_ENGLISH,
SUBLANG_DEFAULT),SORT_DEFAULT));
#endif
// nettoyage des clefs de registres de la version precedente
// si la version qui s'execute n'est pas identique a celle enregistree dans la base de registres
// MFCFP = MFC Feature Pack => pour pouvoir faire cohabiter sur un même PC des versions antérieures à la 1.6.0 et des versions postérieures
// a la 1.6.0
// avant la 1.6.0 => IHM basée sur UltimateToolbox et sauvegarde des caractéristiques des fenêtres à plat dans la base de registre
// à partir de 1.6.0 => IHM basée sur MFC Feature Pack et sauvegarde des caractéristiques des fenêtres dans une arborescence de clefs
// dans la base de registres
// le nettoyage de la base de registres plantait si on essaiyait de revenir à une version < 1.6.0 => on différencie la clef de base
std::string strReg = "\\CurrentUser\\Software\\" + m_versionInfos.GetCompanyName() + "\\" + m_versionInfos.GetProductName() + "MFCFP\\";
g_Registry.SetFullRegistryItem(strReg.c_str());
CString sVersion=g_Registry.GetStringValue(REGISTRY_KEY_VERSION);
CString sProductVersion(m_versionInfos.GetProductVersion().c_str());
if (sVersion != sProductVersion)
{
DeleteRegTree(&g_Registry);
}
g_Registry.Close();
// Pour utilisation de RichEditCtrl
AfxEnableControlContainer();
AfxInitRichEdit();
// InitCommonControlsEx() est requis sur Windows XP si le manifeste de l'application
// spécifie l'utilisation de ComCtl32.dll version 6 ou ultérieure pour activer les
// styles visuels. Dans le cas contraire, la création de fenêtres échouera.
INITCOMMONCONTROLSEX InitCtrls;
InitCtrls.dwSize = sizeof(InitCtrls);
// À définir pour inclure toutes les classes de contrôles communs à utiliser
// dans votre application.
InitCtrls.dwICC = ICC_WIN95_CLASSES;
InitCommonControlsEx(&InitCtrls);
InitContextMenuManager();
InitShellManager();
InitKeyboardManager();
InitTooltipManager();
CMFCToolTipInfo ttParams;
ttParams.m_bVislManagerTheme = TRUE;
GetTooltipManager()->SetTooltipParams(AFX_TOOLTIP_TYPE_ALL, RUNTIME_CLASS(CMFCToolTipCtrl), &ttParams);
// enregistrement Scintilla
#ifndef SCINTILLA_DLL
Scintilla_RegisterClasses(AfxGetInstanceHandle());
Scintilla_LinkLexers();
#endif
// Supprime pour la gestion multi-lingues
// CWinAppEx::InitInstance();
// Initialisation standard
// Si vous n'utilisez pas ces fonctionnalités et que vous souhaitez réduire la taille
// de votre exécutable final, vous devez supprimer ci-dessous
// les routines d'initialisation spécifiques dont vous n'avez pas besoin.
// Changez la clé de Registre sous laquelle nos paramètres sont enregistrés
// TODO : modifiez cette chaîne avec des informations appropriées,
// telles que le nom de votre société ou organisation
SetRegistryKey(m_versionInfos.GetCompanyName().c_str());
//First free the string allocated by MFC at CWinApp startup.
//The string is allocated before InitInstance is called.
free((void*)m_pszProfileName);
//Change the name of the .INI file.
//The CWinApp destructor will free the memory.
// Ce nom est utilise pour la sauvegarde des parametres
strReg = m_versionInfos.GetProductName() + "MFCFP";
m_pszProfileName = _tcsdup(strReg.c_str());
LoadStdProfileSettings(4); // Charge les options de fichier INI standard (y compris les derniers fichiers utilisés)
// Inscrire les modèles de document de l'application. Ces modèles
// lient les documents, fenêtres frame et vues entre eux
// creation du manager de doc specifique afin de gerer specifiquement les repertoires
// de sauvegarde des diffents documents.
// cf http://www.codeguru.com/cpp/w-d/dislog/commondialogs/article.php/c1967
m_pDocManager = new COngTVDocManager;
// Creation doc template pour les scripts LUA (uniquement si DLL scintilla disponible)
if (NULL != m_hSciDLL)
{
m_pNewLuaDocTemplate = new CMultiDocTemplate( IDR_LUATYPE
, RUNTIME_CLASS(CLuaDoc)
, RUNTIME_CLASS(CLuaChildFrame)
, RUNTIME_CLASS(CLuaView)
);
if (!m_pNewLuaDocTemplate)
return FALSE;
AddDocTemplate(m_pNewLuaDocTemplate);
}
// Installe la police DINA
HRSRC hRes = FindResource(NULL, MAKEINTRESOURCE(IDR_DINA), _T("DINA"));
PVOID lpFont = LockResource(LoadResource(NULL, hRes));
DWORD dwSize = SizeofResource(NULL, hRes), cFonts = 0;
m_hDinaFont = AddFontMemResourceEx(lpFont, dwSize, NULL, &cFonts);
ASSERT(cFonts > 0);
// crée la fenêtre frame MDI principale
CMainFrame* pMainFrame = new CMainFrame;
// On parse la ligne de commande
CCmdLine cmdLine;
cmdLine.SplitLine(__argc, __argv);
// On indique le fichier de configuration ("" par defaut)
std::string configFileName = cmdLine.GetSafeArgument("-cnx", 0, "");
pMainFrame->SetConfigFile(configFileName);
m_pMainWnd = pMainFrame;
if (!pMainFrame || !pMainFrame->LoadFrame(IDR_MAINFRAME))
{
delete pMainFrame;
return FALSE;
}
// La fenêtre principale a été initialisée et peut donc être affichée et mise à jour
pMainFrame->ShowWindow(m_nCmdShow);
pMainFrame->UpdateWindow();
return TRUE;
}
BOOL CMDITabsDemoApp::InitInstance()
{
// Initialize OLE libraries
if (!AfxOleInit())
{
AfxMessageBox(IDP_OLE_INIT_FAILED);
return FALSE;
}
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.
// 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("Microsoft\\MFC\\Samples"));
LoadStdProfileSettings(); // Load standard INI file options (including MRU)
SetRegistryBase (_T("Settings"));
m_Options.Load ();
// Initialize all Managers for usage. They are automatically constructed
// if not yet present
InitContextMenuManager();
InitKeyboardManager();
InitTooltipManager ();
CMFCToolTipInfo params;
params.m_bVislManagerTheme = TRUE;
GetTooltipManager ()->SetTooltipParams (
AFX_TOOLTIP_TYPE_ALL,
RUNTIME_CLASS (CMFCToolTipCtrl),
¶ms);
// Register the application's document templates. Document templates
// serve as the connection between documents, frame windows and views.
CMultiDocTemplate* pDocTemplate;
pDocTemplate = new CMultiDocTemplate(
IDR_MDITABTYPE,
RUNTIME_CLASS(CMDITabsDemoDoc),
RUNTIME_CLASS(CChildFrame), // custom MDI child frame
RUNTIME_CLASS(CMDITabsDemoView));
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);
// Dispatch commands specified on the command line
if (!ProcessShellCommand(cmdInfo))
return FALSE;
OnFileNew ();
OnFileNew ();
OnFileNew ();
// The main window has been initialized, so show and update it.
pMainFrame->ShowWindow(m_nCmdShow);
pMainFrame->UpdateWindow();
if (afxGlobalData.m_nBitsPerPixel < 16)
{
AfxMessageBox(IDS_WRONG_DISPLAY_SETTINGS);
}
return TRUE;
}
