--- /dev/null
+//####COPYRIGHTBEGIN####
+//
+// ----------------------------------------------------------------------------
+// Copyright (C) 1998, 1999, 2000 Red Hat, Inc.
+//
+// This program is part of the eCos host tools.
+//
+// This program is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 2 of the License, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the Free Software Foundation, Inc.,
+// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// ----------------------------------------------------------------------------
+//
+//####COPYRIGHTEND####
+#include "stdafx.h"
+
+#include "ConfigToolDoc.h"
+
+#ifdef PLUGIN
+ #include "CTMain.h"
+ #include "Project.h"
+ #include "ProjectManager.h"
+#else
+ #include "MainFrm.h"
+#endif
+
+#include "CTUtils.h"
+#include "CdlPackagesDialog.h"
+#include "ConfigItem.h"
+#include "ConfigTool.h"
+#include "ControlView.h"
+#include "FailingRulesDialog.h"
+#include "FolderDialog.h"
+#include "IdleMessage.h"
+#include "MLTView.h"
+#include "NotePage.h"
+#include "RegionGeneralPage.h"
+#include "RegKeyEx.h"
+#include "RulesView.h"
+#include "SectionGeneralPage.h"
+#include "SectionRelocationPage.h"
+
+#include <htmlhelp.h>
+#include <shlobj.h>
+
+#define INCLUDEFILE <string>
+#include "IncludeSTL.h"
+#define INCLUDEFILE "build.hxx"
+#include "IncludeSTL.h"
+
+#ifdef _DEBUG
+ #define new DEBUG_NEW
+ #undef THIS_FILE
+ static char THIS_FILE[] = __FILE__;
+#endif
+
+const CFileName &CConfigToolDoc::DefaultExternalBrowser()
+{
+ static bool bFirstTime=true;
+ if(bFirstTime){
+ const CFileName strFile(CFileName::GetTempPath()+_T("index.html"));
+ CFile f;
+ if(f.Open(strFile,CFile::modeCreate|CFile::modeWrite)){
+ f.Close();
+ bool rc=((int)FindExecutable(strFile,_T("."),m_strDefaultExternalBrowser.GetBuffer(MAX_PATH))>32);
+ m_strDefaultExternalBrowser.ReleaseBuffer();
+ if(!rc){
+ m_strDefaultExternalBrowser=_T("");
+ }
+ ::DeleteFile(strFile);
+ }
+ bFirstTime=false;
+ }
+ return m_strDefaultExternalBrowser;
+}
+
+CFileName CConfigToolDoc::m_strDefaultExternalBrowser;
+
+void CConfigToolDoc::CheckRadios()
+{
+ for(int nItem=0;nItem<ItemCount();nItem++){
+ CConfigItem *pItem=Item(nItem);
+ if(pItem->HasRadio () && pItem==pItem->FirstRadio()){
+ CString strMsg;
+ CConfigItem *pFirstSet=NULL;
+ for(CConfigItem *pSibItem=pItem;pSibItem;pSibItem=pSibItem->NextRadio()){
+ if(pSibItem->IsEnabled ()){
+ if(pFirstSet){
+ strMsg+=_T(" ");
+ strMsg+=pSibItem->Macro ();
+ } else {
+ pFirstSet=pSibItem;
+ }
+ }
+ }
+ if(!strMsg.IsEmpty()){
+ CConfigTool::Log(_T("%s, multiple radio buttons are set: %s%s"),
+ pItem->Macro(),pFirstSet->Macro(),strMsg);
+ } else if(!pFirstSet){
+ CConfigTool::Log(_T("%s, no radio buttons are set"),pItem->Macro());
+ }
+ }
+ }
+}
+
+// Find the ConfigItem referencing the given CdlValuable
+CConfigItem * CConfigToolDoc::Find (CdlValuable v)
+{
+ for(int nItem=0;nItem<ItemCount();nItem++){
+ CConfigItem *pItem=Item(nItem);
+ if(v==pItem->GetCdlValuable()){
+ return pItem;
+ }
+ }
+ return NULL;
+}
+
+CConfigItem * CConfigToolDoc::Find(const CString & strWhat,WhereType where)
+{
+ for(int nItem=0;nItem<ItemCount();nItem++){
+ CConfigItem *pItem=Item(nItem);
+ if(0==pItem->StringValue(where).Compare(strWhat)){
+ return pItem;
+ }
+ }
+ return NULL;
+}
+
+void CConfigToolDoc::OnMLTNewRegion()
+{
+ // create the property sheet
+
+ CPropertySheet prsRegionSheet (IDS_NEW_REGION_SHEET_TITLE, CConfigTool::GetMLTView());
+
+ // add the property pages
+
+ CRegionGeneralPage prpGeneral;
+ CNotePage prpNote;
+
+ prsRegionSheet.AddPage (&prpGeneral);
+ prsRegionSheet.AddPage (&prpNote);
+
+ // setup initial values
+
+ prpGeneral.m_strRegionName = _T("");
+ prpGeneral.m_dwRegionStartAddress = 0;
+ prpGeneral.m_dwRegionSize = 0;
+
+ // show property sheet
+
+ if (prsRegionSheet.DoModal () == IDOK)
+ {
+ if (int nErrorCode = MemoryMap.create_memory_region (CUtils::UnicodeToStdStr(prpGeneral.m_strRegionName), prpGeneral.m_dwRegionStartAddress, prpGeneral.m_dwRegionSize, (prpGeneral.m_bRegionReadOnly ? read_only : read_write), CUtils::UnicodeToStdStr(prpNote.m_strNote)))
+ ErrorBox (IDS_ERR_MEMMAP_REGION_CREATE, IDS_ERR_MEMMAP_BASE + nErrorCode);
+ else // no errors
+ {
+ SetModifiedFlag ();
+ UpdateAllViews (NULL, MemLayoutChanged);
+ }
+ }
+}
+
+void CConfigToolDoc::ErrorBox (UINT uIDSIntro, UINT uIDSError)
+{
+ CString strIntro, strError;
+ strIntro.LoadString (uIDSIntro);
+ strError.LoadString (uIDSError);
+ AfxMessageBox (strIntro + _T("\n\n") + strError);
+}
+
+void CConfigToolDoc::OnMLTNewSection()
+{
+ // create the property sheet
+
+ CPropertySheet prsSectionSheet (IDS_NEW_SECTION_SHEET_TITLE, CConfigTool::GetMLTView());
+
+ // add the property pages
+
+ CSectionGeneralPage prpGeneral;
+ CSectionRelocationPage prpRelocation;
+ CNotePage prpNote;
+
+ prsSectionSheet.AddPage (&prpGeneral);
+ prsSectionSheet.AddPage (&prpRelocation);
+ prsSectionSheet.AddPage (&prpNote);
+
+ // initialise for a new section
+
+ prpGeneral.m_bNameLinkerDefined = TRUE;
+ prpGeneral.m_strNameLinker = _T("");
+ prpRelocation.m_bRelocates = FALSE;
+ prpRelocation.m_bNewSection = TRUE;
+
+ // show property sheet
+
+ if (prsSectionSheet.DoModal () == IDOK)
+ {
+ mem_anchor initial_anchor, final_anchor;
+ mem_address initial_address;
+ CString strInitialRelativeName = _T("");
+
+ if (prpGeneral.m_bFinalAbsolute) // final location is an absolute location
+ final_anchor = absolute;
+ else // final location is a relative location
+ final_anchor = relative;
+
+ if (prpRelocation.m_bRelocates) // if the section relocates
+ {
+ if (prpRelocation.m_bInitialAbsolute) // initial location is an absolute location
+ {
+ initial_anchor = absolute;
+ }
+ else // initial location is a relative location
+ {
+ strInitialRelativeName = prpRelocation.m_strInitialRelativeName;
+ initial_anchor = relative;
+ }
+ initial_address = prpRelocation.m_dwInitialAddress;
+ }
+ else
+ {
+ strInitialRelativeName = prpGeneral.m_strFinalRelativeName;
+ initial_anchor = final_anchor;
+ initial_address = prpGeneral.m_dwFinalAddress;
+ }
+
+
+ if (int nErrorCode = MemoryMap.create_memory_section (CUtils::UnicodeToStdStr(prpGeneral.m_bNameLinkerDefined ? prpGeneral.m_strNameLinker : prpGeneral.m_strNameUser), prpGeneral.m_dwSectionSize, prpGeneral.m_dwAlignment, initial_anchor, CUtils::UnicodeToStdStr(strInitialRelativeName), initial_address, final_anchor, CUtils::UnicodeToStdStr(prpGeneral.m_strFinalRelativeName), prpGeneral.m_dwFinalAddress, prpRelocation.m_bRelocates, false, prpGeneral.m_bNameLinkerDefined, CUtils::UnicodeToStdStr(prpNote.m_strNote)))
+ ErrorBox (IDS_ERR_MEMMAP_SECTION_CREATE, IDS_ERR_MEMMAP_BASE + nErrorCode);
+ else // no errors
+ {
+ SetModifiedFlag ();
+ UpdateAllViews (NULL, MemLayoutChanged);
+ }
+ }
+}
+
+void CConfigToolDoc::OnMLTDelete()
+{
+ if (strSelectedSection != _T("")) // a section is selected
+ {
+ if (MemoryMap.delete_memory_section (CUtils::UnicodeToStdStr(strSelectedSection)))
+ {
+ strSelectedSection = _T("");
+ SetModifiedFlag ();
+ UpdateAllViews (NULL, MemLayoutChanged);
+ }
+ else
+ AfxMessageBox (_T("Could not delete memory section.\n\nMake sure there are no other sections defined relative to this one."));
+ }
+ else if (strSelectedRegion != _T("")) // a region is selected
+ {
+ if (MemoryMap.delete_memory_region (CUtils::UnicodeToStdStr(strSelectedRegion)))
+ {
+ strSelectedRegion = _T("");
+ SetModifiedFlag ();
+ UpdateAllViews (NULL, MemLayoutChanged);
+ }
+ else
+ AfxMessageBox (_T("Could not delete memory region.\n\nMake sure it is not in use.")); // FIXME
+ }
+}
+
+void CConfigToolDoc::ShowRegionProperties()
+{
+ // create the property sheet
+
+ CString strTitle;
+ strTitle.LoadString (IDS_REGION_PROPERTIES_SHEET_TITLE);
+ CPropertySheet prsRegionSheet (strSelectedRegion + _T(" - ") + strTitle, CConfigTool::GetMLTView());
+
+ // add the property pages
+
+ CRegionGeneralPage prpGeneral;
+ CNotePage prpNote;
+
+ prsRegionSheet.AddPage (&prpGeneral);
+ prsRegionSheet.AddPage (&prpNote);
+
+ // set up property sheet values
+
+ mem_type type;
+ std::string note;
+ MemoryMap.get_memory_region (CUtils::UnicodeToStdStr(strSelectedRegion), &prpGeneral.m_dwRegionStartAddress, &prpGeneral.m_dwRegionSize, &type, ¬e);
+ prpGeneral.m_strRegionName = strSelectedRegion;
+ prpGeneral.m_bRegionReadOnly = (type == read_only);
+ prpNote.m_strNote = note.c_str ();
+
+ // show property sheet
+
+ if (prsRegionSheet.DoModal () == IDOK)
+ {
+ if (int nErrorCode = MemoryMap.edit_memory_region (CUtils::UnicodeToStdStr(strSelectedRegion), CUtils::UnicodeToStdStr(prpGeneral.m_strRegionName), prpGeneral.m_dwRegionStartAddress, prpGeneral.m_dwRegionSize, (prpGeneral.m_bRegionReadOnly ? read_only : read_write), CUtils::UnicodeToStdStr(prpNote.m_strNote)))
+ ErrorBox (IDS_ERR_MEMMAP_REGION_MODIFY, IDS_ERR_MEMMAP_BASE + nErrorCode);
+ else // no errors
+ {
+ SetModifiedFlag ();
+ UpdateAllViews (NULL, MemLayoutChanged);
+ }
+ }
+}
+
+void CConfigToolDoc::ShowSectionProperties()
+{
+ // create the property sheet
+
+ CString strTitle;
+ strTitle.LoadString (IDS_SECTION_PROPERTIES_SHEET_TITLE);
+ CPropertySheet prsSectionSheet (strSelectedSection + _T(" - ") + strTitle, CConfigTool::GetMLTView());
+
+ // add the property pages
+
+ CSectionGeneralPage prpGeneral;
+ CSectionRelocationPage prpRelocation;
+ CNotePage prpNote;
+
+ prsSectionSheet.AddPage (&prpGeneral);
+ prsSectionSheet.AddPage (&prpRelocation);
+ prsSectionSheet.AddPage (&prpNote);
+
+ // setup initial values
+
+ std::list <mem_section>::iterator section = MemoryMap.find_memory_section (CUtils::UnicodeToStdStr(strSelectedSection));
+ prpGeneral.m_bNameLinkerDefined = (section->linker_defined);
+ if (prpGeneral.m_bNameLinkerDefined)
+ prpGeneral.m_strNameLinker = section->name.c_str ();
+ else
+ {
+ prpGeneral.m_strNameUser = section->name.c_str ();
+ prpGeneral.m_dwSectionSize = section->size;
+ }
+
+ prpGeneral.m_bFinalAbsolute = (section->final_location->anchor == absolute);
+ if (prpGeneral.m_bFinalAbsolute)
+ prpGeneral.m_dwFinalAddress = section->final_location->address;
+ else
+ {
+ prpGeneral.m_strFinalRelativeName = MemoryMap.find_preceding_section (section, false)->name.c_str ();
+ prpGeneral.m_dwAlignment = section->alignment;
+ }
+
+ prpRelocation.m_bRelocates = section->relocates;
+ if (prpRelocation.m_bRelocates)
+ {
+ prpRelocation.m_bInitialAbsolute = (section->initial_location->anchor == absolute);
+ if (prpRelocation.m_bInitialAbsolute)
+ prpRelocation.m_dwInitialAddress = section->initial_location->address;
+ else
+ prpRelocation.m_strInitialRelativeName = MemoryMap.find_preceding_section (section, true)->name.c_str ();
+ }
+
+ prpNote.m_strNote = section->note.c_str ();
+
+ // show property sheet
+
+ if (prsSectionSheet.DoModal () == IDOK)
+ {
+ mem_anchor initial_anchor, final_anchor;
+ mem_address initial_address;
+ CString strInitialRelativeName = _T("");
+
+ if (prpGeneral.m_bFinalAbsolute) // final location is an absolute location
+ final_anchor = absolute;
+ else // final location is a relative location
+ final_anchor = relative;
+
+ if (prpRelocation.m_bRelocates) // if the section relocates
+ {
+ if (prpRelocation.m_bInitialAbsolute) // initial location is an absolute location
+ {
+ initial_anchor = absolute;
+ }
+ else // initial location is a relative location
+ {
+ strInitialRelativeName = prpRelocation.m_strInitialRelativeName;
+ initial_anchor = relative;
+ }
+ initial_address = prpRelocation.m_dwInitialAddress;
+ }
+ else
+ {
+ strInitialRelativeName = prpGeneral.m_strFinalRelativeName;
+ initial_anchor = final_anchor;
+ initial_address = prpGeneral.m_dwFinalAddress;
+ }
+
+
+ if (int nErrorCode = MemoryMap.edit_memory_section (CUtils::UnicodeToStdStr(strSelectedSection), CUtils::UnicodeToStdStr(prpGeneral.m_bNameLinkerDefined ? prpGeneral.m_strNameLinker : prpGeneral.m_strNameUser), prpGeneral.m_dwSectionSize, prpGeneral.m_dwAlignment, initial_anchor, CUtils::UnicodeToStdStr(strInitialRelativeName), initial_address, final_anchor, CUtils::UnicodeToStdStr(prpGeneral.m_strFinalRelativeName), prpGeneral.m_dwFinalAddress, prpRelocation.m_bRelocates, false, prpGeneral.m_bNameLinkerDefined, CUtils::UnicodeToStdStr(prpNote.m_strNote)))
+ ErrorBox (IDS_ERR_MEMMAP_SECTION_MODIFY, IDS_ERR_MEMMAP_BASE + nErrorCode);
+ else // no errors
+ {
+ SetModifiedFlag ();
+ UpdateAllViews (NULL, MemLayoutChanged);
+ }
+ }
+}
+
+void CConfigToolDoc::OnMLTProperties()
+{
+ if (strSelectedRegion != _T(""))
+ ShowRegionProperties ();
+ else if (strSelectedSection != _T(""))
+ ShowSectionProperties ();
+}
+
+// Choose a default Hal. Do this using clues the installer may have helpfully left behind (PR 18050)
+// or else if there is only one possible choice, by choosing that one :-).
+/*
+void CConfigToolDoc::ChooseDefaultHal()
+{
+bool bFound=false;
+// Has the installer told us?
+LPCTSTR pszRegPath=_T("SOFTWARE\\Red Hat\\eCos\\1.2.8");
+HKEY hKey;
+if(ERROR_SUCCESS==RegOpenKeyEx (HKEY_LOCAL_MACHINE, pszRegPath, 0L, KEY_READ, &hKey)){
+DWORD dwSizePath=MAX_PATH;
+CString str;
+PTCHAR psz=str.GetBuffer(dwSizePath);
+if(ERROR_SUCCESS==RegQueryValueEx(hKey, _T("Default Architecture"), NULL, NULL, (LPBYTE)psz, &dwSizePath)){
+str.MakeLower();
+for(int nItem=0;nItem<ItemCount();nItem++){
+CConfigItem *pItem=Item(nItem);
+if(pItem->m_pTarget){
+CString strTarget(pItem->m_pTarget->Name());
+strTarget.MakeLower();
+if(-1!=str.Find(strTarget)){
+bFound=true;
+dwSizePath=MAX_PATH;
+if(ERROR_SUCCESS==::RegQueryValueEx(hKey, _T("Default Build Tools Path"), NULL, NULL, (LPBYTE)psz, &dwSizePath)){
+pItem->m_pTarget->SetBinDir(psz);
+for(CConfigItem *pSib=pItem->FirstRadio();pSib;pSib=pSib->NextRadio()){
+pSib->SetValue((ItemIntegerType) (pSib==pItem));
+}
+// pItem->EnableAncestors();
+}
+break;
+}
+}
+}
+}
+RegCloseKey(hKey);
+}
+
+ if(!bFound){
+ // No - choose the Hal according to toolchain
+ for(int nItem=0;nItem<ItemCount();nItem++){
+ CConfigItem *pItem=Item(nItem);
+ if(pItem->m_pTarget){
+ CString strTarget(pItem->m_pTarget->Name());
+ strTarget.MakeLower();
+ for(int j=0;j<m_arstrToolChainPaths.GetSize();j++){
+ CString strTools(m_arstrToolChainPaths[j]);
+ strTools.MakeLower();
+ if(-1!=strTools.Find(strTarget)){
+ for(CConfigItem *pSib=pItem->FirstRadio();pSib;pSib=pSib->NextRadio()){
+ pSib->SetValue((ItemIntegerType) (pSib==pItem));
+ }
+ return;
+ }
+ }
+ }
+ }
+ }
+ }
+*/
+
+bool CConfigToolDoc::SetValue (CConfigItem &ti, double dValue, CdlTransaction transaction/*=NULL*/)
+{
+ ASSERT (ti.Type () == CConfigItem::Double);
+
+ // test if the new double value is in range
+ const CdlValuable valuable = ti.GetCdlValuable();
+ CdlListValue list_value;
+ CdlEvalContext context (NULL, ti.GetCdlItem (), ti.GetCdlItem ()->get_property (CdlPropertyId_LegalValues));
+ valuable->get_legal_values ()->eval (context, list_value);
+ if (! list_value.is_member (dValue))
+ {
+ if (dValue==valuable->get_double_value(CdlValueSource_Current) || IDNO == CUtils::MessageBoxFT (MB_YESNO, _T("%s is not a legal value for %s.\n\nDo you want to use this value anyway?"),
+ CUtils::DoubleToStr (dValue), ti.Macro ()))
+ return false;
+ }
+
+ if (! ti.SetValue (dValue,transaction))
+ return false;
+
+ SetModifiedFlag ();
+ return true;
+}
+bool CConfigToolDoc::SetValue(CConfigItem &ti,const CString &strValue, CdlTransaction transaction/*=NULL*/)
+{
+ // warn the user if a modified memory layout is about to be discarded
+ if (MemoryMap.map_modified () && (ti.Macro () == _T("CYG_HAL_STARTUP")) &&
+ (IDCANCEL == CUtils::MessageBoxFT (MB_OKCANCEL, _T("Changes to the current memory layout will be lost."))))
+ return false;
+
+ bool rc=false;
+ switch(ti.Type()){
+ case CConfigItem::None:
+ break;
+ case CConfigItem::Enum:
+ case CConfigItem::String:
+ rc=ti.SetValue(strValue,transaction);
+ break;
+ case CConfigItem::Integer:
+ {
+ ItemIntegerType n;
+ rc=CUtils::StrToItemIntegerType(strValue,n) && SetValue(ti,n,transaction);
+ }
+ break;
+ case CConfigItem::Double:
+ {
+ double dValue;
+ rc = CUtils::StrToDouble (strValue, dValue) && SetValue (ti, dValue,transaction);
+ }
+ break;
+ default:
+ ASSERT(FALSE);
+ break;
+
+ }
+ if(rc){
+ SetModifiedFlag();
+ UpdateAllViews (NULL, CConfigToolDoc::ValueChanged, (CObject *)&ti);
+ }
+ return rc;
+}
+
+// Look in registry to match prefixes CYGPKG_HAL_ and CYGHWR_HAL_:
+//
+bool CConfigToolDoc::GetRunPlatform(CString &strTarget)
+{
+ CRegKeyEx k1(HKEY_CURRENT_USER,_T("Software\\Red Hat\\eCos\\Platforms"), KEY_READ);
+ CString strKey;
+ for(int i=0;k1.QueryKey(i,strKey);i++){
+ CRegKeyEx k2((HKEY)k1,strKey,KEY_READ);
+ // Subkeys' names are the target image names [one of which we aim to return]
+ // Subkeys's values of interest are:
+ // Prefix String
+ // Sim DWORD [optional]
+ // Macro String
+ DWORD dwSim=0;
+ CString strPrefix,strMacro;
+ k2.QueryValue(_T("Sim"),dwSim);
+ k2.QueryValue(_T("Prefix"),strPrefix);
+ k2.QueryValue(_T("Macro"),strMacro);
+
+ CConfigItem *pItem=Find(_T("CYGPKG_HAL_")+strMacro);
+ if(pItem && pItem->IsEnabled()){
+ // We have found what we are looking for - probably
+ pItem=Find(_T("CYGHWR_HAL_")+strMacro+_T("_STARTUP"));
+ if(pItem){
+ // Two platforms apply - choose this one only if the ram startup attribute fits
+ if( (dwSim==0) == (0==pItem->StringValue().CompareNoCase(_T("ram"))) ) {
+ strTarget=strKey;
+ }
+ } else {
+ // Only one platform applies
+ strTarget=strKey;
+ }
+
+ }
+ }
+ return !strTarget.IsEmpty();
+}
+
+bool CConfigToolDoc::SetEnabled(CConfigItem &ti, bool bEnabled, CdlTransaction transaction/*=NULL*/)
+{
+ const bool bStatus = ti.SetEnabled (bEnabled,transaction);
+
+ if (bStatus) {
+ SetModifiedFlag();
+ UpdateAllViews (NULL, CConfigToolDoc::ValueChanged, (CObject *) &ti);
+ }
+ return bStatus;
+}
+
+void CConfigToolDoc::AddContents (const CdlContainer container, CConfigItem *pParent)
+{
+
+ // determine the container contents
+
+ const std::vector<CdlNode>& contents = container->get_contents ();
+ std::vector<CdlNode>::const_iterator node_i;
+ for (node_i = contents.begin (); node_i != contents.end (); node_i++)
+ {
+ const CdlNode node = * node_i;
+ const CdlPackage pkg = dynamic_cast<CdlPackage> (node);
+ const CdlComponent comp = dynamic_cast<CdlComponent> (node);
+ const CdlOption opt = dynamic_cast<CdlOption> (node);
+ const CdlContainer contnr = dynamic_cast<CdlContainer> (node);
+
+ // if the node in the container is a package, component or option
+ // then it is visible and should be added to the tree
+ if (0 != pkg) // the node is a package
+ {
+ CConfigItem * pItem = AddItem (pkg, pParent); // add the package
+ AddContents (pkg, pItem); // add the package contents
+ }
+ else if (0 != comp) // the node is a component
+ {
+ CConfigItem * pItem = AddItem (comp, pParent); // add the component
+ AddContents (comp, pItem); // add the component contents
+ }
+ else if (0 != opt) // the node is an option
+ AddItem (opt, pParent); // add the option
+
+ else if (0 != contnr) // if the node is a container
+ AddContents (contnr, pParent); // add the container contents
+
+ // ignore nodes of any other class
+ }
+}
+
+// Three hack functions.
+
+const CString CConfigToolDoc::CurrentPlatform()
+{
+/*
+for(int nItem=0;nItem<ItemCount();nItem++){
+CConfigItem *pItem=Item(nItem);
+if(pItem->IsEnabled() && !pItem->Platform().IsEmpty()){
+return pItem->Platform();
+}
+}
+ */
+ return _T("");
+}
+
+// a trivial CDL parse error handler
+void CConfigToolDoc::CdlParseErrorHandler (std::string message)
+{
+ CConfigToolDoc *pDoc=CConfigTool::GetConfigToolDoc();
+ pDoc->m_strCdlErrorMessage = message.c_str ();
+ TRACE (_T("CdlParseError: %s\n"), pDoc->m_strCdlErrorMessage);
+ CConfigTool::Log (CUtils::StripExtraWhitespace (pDoc->m_strCdlErrorMessage)); // display the message in the output window
+};
+
+// a trivial CDL parse warning handler
+void CConfigToolDoc::CdlParseWarningHandler (std::string message)
+{
+ CConfigToolDoc *pDoc=CConfigTool::GetConfigToolDoc();
+ pDoc->m_strCdlErrorMessage = message.c_str ();
+ TRACE (_T("CdlParseWarning: %s\n"), pDoc->m_strCdlErrorMessage);
+ CConfigTool::Log (CUtils::StripExtraWhitespace (pDoc->m_strCdlErrorMessage)); // display the message in the output window
+};
+
+// a trivial CDL load error handler
+void CConfigToolDoc::CdlLoadErrorHandler (std::string message)
+{
+ CConfigToolDoc *pDoc=CConfigTool::GetConfigToolDoc();
+ pDoc->m_strCdlErrorMessage = message.c_str ();
+ TRACE (_T("CdlLoadError: %s\n"), pDoc->m_strCdlErrorMessage);
+ CConfigTool::Log (CUtils::StripExtraWhitespace (pDoc->m_strCdlErrorMessage)); // display the message in the output window
+};
+
+// a trivial CDL load warning handler
+void CConfigToolDoc::CdlLoadWarningHandler (std::string message)
+{
+ CConfigToolDoc *pDoc=CConfigTool::GetConfigToolDoc();
+ pDoc->m_strCdlErrorMessage = message.c_str ();
+ TRACE (_T("CdlLoadWarning: %s\n"), pDoc->m_strCdlErrorMessage);
+ CConfigTool::Log (CUtils::StripExtraWhitespace (pDoc->m_strCdlErrorMessage)); // display the message in the output window
+};
+
+CdlInferenceCallbackResult CConfigToolDoc::CdlGlobalInferenceHandler(CdlTransaction transaction)
+{
+ CConfigToolDoc *pDoc=CConfigTool::GetConfigToolDoc();
+ pDoc->m_ConflictsOutcome=NotDone; // prepare for the case that there are no solutions
+ CdlInferenceCallbackResult rc=CdlInferenceCallbackResult_Continue;
+ /*
+ std::list<CdlConflict>conflicts1(transaction->get_global_conflicts_with_solutions());
+ const std::vector<CdlConflict>&conflicts2=transaction->get_resolved_conflicts();
+ for (unsigned int i = 0; i < conflicts2.size (); i++) {
+ conflicts1.push_back(conflicts2 [i]);
+ }
+ if(conflicts1.size()>0){
+ CFailingRulesDialog dlg(conflicts1,transaction,&pDoc->m_arConflictsOfInterest);
+ rc=(IDOK==dlg.DoModal())?CdlInferenceCallbackResult_Continue:CdlInferenceCallbackResult_Cancel;
+ pDoc->m_ConflictsOutcome=(CdlInferenceCallbackResult_Continue==rc)?OK:Cancel;
+ }
+ */
+ const std::list<CdlConflict>& conflicts=pDoc->GetCdlConfig()->get_all_conflicts();
+ CFailingRulesDialog dlg(conflicts,transaction,&pDoc->m_arConflictsOfInterest);
+ rc=(IDOK==dlg.DoModal())?CdlInferenceCallbackResult_Continue:CdlInferenceCallbackResult_Cancel;
+ pDoc->m_ConflictsOutcome=(CdlInferenceCallbackResult_Continue==rc)?OK:Cancel;
+
+ return rc;
+}
+
+CdlInferenceCallbackResult CConfigToolDoc::CdlInferenceHandler (CdlTransaction transaction)
+{
+ CConfigToolDoc *pDoc=CConfigTool::GetConfigToolDoc();
+ CdlInferenceCallbackResult rc=CdlInferenceCallbackResult_Continue;
+ const std::list<CdlConflict>&conflicts=transaction->get_new_conflicts();
+ if((pDoc->m_nRuleChecking&Immediate) && conflicts.size()>0){
+ if(pDoc->m_nRuleChecking&SuggestFixes){
+ std::list<CdlConflict> s_conflicts;
+ for (std::list<CdlConflict>::const_iterator conf_i= conflicts.begin (); conf_i != conflicts.end (); conf_i++) { // for each conflict
+ if((*conf_i)->has_known_solution()){
+ s_conflicts.push_back(*conf_i);
+ }
+ }
+ if(s_conflicts.size()>0){
+ CFailingRulesDialog dlg(s_conflicts,transaction);
+ return(IDOK==dlg.DoModal()?CdlInferenceCallbackResult_Continue:CdlInferenceCallbackResult_Cancel);
+ }
+ }
+ CString strMsg;
+ if(1==conflicts.size()){
+ strMsg=(_T("There is 1 unresolved conflict."));
+ } else {
+ strMsg.Format(_T("There are %d unresolved conflict%s."),conflicts.size(),1==conflicts.size()?_T(""):_T("s"));
+ }
+ rc=(IDYES==CUtils::MessageBoxFT(MB_YESNO|MB_DEFBUTTON2,_T("%s Make the change anyway?"),strMsg))?CdlInferenceCallbackResult_Continue:CdlInferenceCallbackResult_Cancel;
+ }
+ return rc;
+}
+
+
+// a CDL transaction handler to refresh the configuration tree
+void CConfigToolDoc::CdlTransactionHandler (const CdlTransactionCallback & data)
+{
+static int nNesting=0;
+TRACE(_T("Transaction handler: nesting level=%d\n"),nNesting++);
+ CConfigToolDoc *pDoc=CConfigTool::GetConfigToolDoc();
+ std::vector<CdlValuable>::const_iterator val_i;
+ std::vector<CdlNode>::const_iterator node_i;
+ std::list<CdlConflict>::const_iterator conf_i;
+ CControlView *pControlView=CConfigTool::GetControlView();
+ for (val_i = data.value_changes.begin(); val_i != data.value_changes.end(); val_i++)
+ {
+ const CString strName((*val_i)->get_name().c_str());
+ TRACE(_T("%s %s : value change\n"), CString ((*val_i)->get_class_name().c_str()), strName);
+ pControlView->Refresh(strName);
+ if (strName==_T("CYGHWR_MEMORY_LAYOUT")){ // the memory layout has changed...
+ pDoc->SwitchMemoryLayout (false); // ...so display a new one
+ }
+ }
+ for (node_i = data.active_changes.begin(); node_i != data.active_changes.end(); node_i++)
+ {
+ const CString strName((*node_i)->get_name().c_str());
+ TRACE(_T("%s %s : this has become active or inactive\n"), CString ((*node_i)->get_class_name().c_str()),
+ CString ((*node_i)->get_name().c_str()));
+ if (! dynamic_cast<CdlInterface> (*node_i)){ // if not an interface node
+ pControlView->Refresh(strName);
+ }
+ }
+ for (val_i = data.legal_values_changes.begin(); val_i != data.legal_values_changes.end(); val_i++)
+ {
+ const CString strName((*node_i)->get_class_name().c_str());
+ TRACE(_T("%s %s : the legal_values list has changed, a new widget may be needed.\n"),
+ CString ((*val_i)->get_class_name().c_str()), strName);
+ }
+
+ for (val_i = data.value_source_changes.begin(); val_i != data.value_source_changes.end(); val_i++)
+ {
+ const CString strName((*val_i)->get_name().c_str());
+ CdlValueSource source = (*val_i)->get_source();
+ TRACE(_T("%s %s : the value source has changed to %s\n"),
+ CString ((*val_i)->get_class_name().c_str()), strName,
+ CString ((CdlValueSource_Default == source) ? "default" :
+ (CdlValueSource_Inferred == source) ? "inferred" :
+ (CdlValueSource_Wizard == source) ? "wizard" : "user"));
+ pControlView->Refresh (strName);
+ }
+
+ pDoc->UpdateFailingRuleCount();
+nNesting--;
+}
+
+// Three hack functions.
+
+const CString CConfigToolDoc::CurrentMemoryLayout ()
+{
+ const CConfigItem * pItem = Find (_T("CYGHWR_MEMORY_LAYOUT"));
+#ifdef _DEBUG
+ if(NULL==pItem){
+ TRACE(_T("Warning - CurrentMemoryLayout() returning NULL\n"));
+ }
+#endif
+ return pItem ? pItem->StringValue () : _T("");
+}
+
+const CString CConfigToolDoc::CurrentTestingIdentifier ()
+{
+ // use the CDL target as the default testing identifier
+ // override in the forthcoming testing identifier dialog as necessary
+ return GetCdlConfig()->get_hardware ().c_str ();
+
+// const CConfigItem * pItem = Find (_T("CYGTST_TESTING_IDENTIFIER"));
+//#ifdef _DEBUG
+// if(NULL==pItem){
+// TRACE(_T("Warning - CurrentTestingIdentifier() returning NULL\n"));
+// }
+//#endif
+// return pItem ? pItem->StringValue () : _T("");
+}
+
+const CString CConfigToolDoc::CurrentStartup()
+{
+ const CConfigItem * pItem = Find (_T("CYG_HAL_STARTUP"));
+#ifdef _DEBUG
+ if(NULL==pItem){
+ TRACE(_T("Warning - CurrentStartup() returning NULL\n"));
+ }
+#endif
+ return pItem ? pItem->StringValue () : _T("");
+
+ /*
+ for(int nItem=0;nItem<ItemCount();nItem++){
+ CConfigItem *pItem=Item(nItem);
+ const CString strName(pItem->Name());
+ if(0==strName.Compare(_T("Startup type")) && pItem->IsEnabled()){
+ return pItem->StringValue();
+ }
+ }
+ return _T("ram"); // FIXME - assume ram startup for now if no startup item
+ */
+}
+
+void CConfigToolDoc::UpdateFailingRuleCount()
+{
+ int nCount=0;
+ if (GetCdlConfig ()){
+ // if configuration information
+
+ // calculate the number of conflicts
+ nCount =
+ // GetCdlConfig ()->get_structural_conflicts ().size () + ignore for now
+ GetCdlConfig ()->get_all_conflicts ().size ();
+
+ // update the conflicts view
+ if (CConfigTool::GetRulesView ()) {
+ CConfigTool::GetRulesView ()->FillRules ();
+ }
+ }
+ if(CConfigTool::GetMain()){
+ CConfigTool::GetMain()->SetFailRulePane(nCount);
+ }
+}
+
+void CConfigToolDoc::LogConflicts (const std::list<CdlConflict> & conflicts)
+{
+ std::list<CdlConflict>::const_iterator conf_i;
+ for (conf_i = conflicts.begin (); conf_i != conflicts.end (); conf_i++) // for each conflict
+ {
+ CString strExplain = (* conf_i)->get_explanation ().c_str (); // get the conflict explanation
+ CConfigTool::Log (CUtils::StripExtraWhitespace (strExplain)); // display the message in the output window
+ }
+}
+
+CString CConfigToolDoc::GetPackageName (const CString & strAlias)
+{
+ const std::vector<std::string> & packages = m_CdlPkgData->get_packages ();
+ std::vector<std::string>::const_iterator package_i;
+ for (package_i = packages.begin (); package_i != packages.end (); package_i++)
+ {
+ const std::vector<std::string> & aliases = m_CdlPkgData->get_package_aliases (* package_i);
+ CString strPackageAlias = aliases [0].c_str ();
+ if (aliases.size () && (0 == strAlias.Compare (strPackageAlias)))
+ return package_i->c_str ();
+ }
+ return _T("");
+}
+
+void CConfigToolDoc::DeleteContents()
+{
+ TRACE(_T("###DeleteContents()\n"));
+#ifndef PLUGIN
+ CDocument::DeleteContents();
+#endif
+
+ RemoveAllItems();
+ TRACE(_T("###DeleteContents done\n"));
+}
+
+void CConfigToolDoc::SelectPackages ()
+{
+ CCdlPackagesDialog dlg;
+ // This map holds the CConfigItem pointers for the packages loaded before the dialog is invoked.
+ // We cannot use Find(), which traverses all items - potentially those that have been removed
+ CMapStringToPtr arLoadedPackages;
+
+ // generate the contents of the add/remove list boxes
+ const std::vector<std::string> & packages = m_CdlPkgData->get_packages ();
+ std::vector<std::string>::const_iterator package_i;
+ for (package_i = packages.begin (); package_i != packages.end (); package_i++)
+ {
+ // if (! m_CdlPkgData->is_hardware_package (* package_i)) // do not list hardware packages
+ {
+ const std::vector<std::string> & aliases = m_CdlPkgData->get_package_aliases (* package_i);
+ CString strMacroName = package_i->c_str ();
+
+ // use the first alias (if any) as the package identifier
+ CString strPackageName = aliases.size () ? aliases [0].c_str () : strMacroName;
+ CConfigItem * pItem = Find (strMacroName);
+ if (pItem) // if the package is loaded
+ {
+ arLoadedPackages.SetAt(strMacroName,pItem);
+ // pass the currently selected package version string to the dialog box
+ const CdlValuable valuable = pItem->GetCdlValuable();
+ dlg.Insert (strPackageName, TRUE, NULL, valuable ? (LPCTSTR) CString (valuable->get_value ().c_str ()) : NULL);
+ }
+ else
+ {
+ // pass version string of the most latest version to the dialog box
+ dlg.Insert (strPackageName, FALSE, NULL, (LPCTSTR) CString (m_CdlPkgData->get_package_versions (* package_i) [0].c_str ()));
+ }
+ }
+ }
+
+ if (IDOK == dlg.DoModal ())
+ {
+ bool bChanged = false; // until proved otherwise
+
+ // determine whether each package has changed loaded/unloaded state
+ for (package_i = packages.begin (); package_i != packages.end (); package_i++)
+ // if (! m_CdlPkgData->is_hardware_package (* package_i)) // do not check hardware packages
+ {
+ const std::vector<std::string> & aliases = m_CdlPkgData->get_package_aliases (* package_i);
+ CString strMacroName = package_i->c_str ();
+
+ // use the first alias (if any) as the package identifier
+ CString strPackageName = aliases.size () ? aliases [0].c_str () : strMacroName;
+
+ CConfigItem *pItem=NULL;
+ bool bPreviouslyLoaded=arLoadedPackages.Lookup(strMacroName,(void *&)pItem);
+ bool bNowLoaded=dlg.IsAdded (strPackageName);
+
+ // unload packages which are no longer required before
+ // loading new ones to avoid potential duplicate macro definitions
+ if (! bNowLoaded && bPreviouslyLoaded){
+ // The package was loaded but should now be unloaded:
+ bChanged|=pItem->Unload();
+ } else if (bNowLoaded) {// if the package should be loaded
+ const CString strVersion(dlg.GetVersion (strPackageName));
+ if (bPreviouslyLoaded) { // if the package is already loaded
+ CdlTransactionCallback::set_callback_fn (NULL); // avoid value refresh attempts during load/unload
+ bChanged|=pItem->ChangeVersion(strVersion);
+ CdlTransactionCallback::set_callback_fn (CdlTransactionHandler); // restore value refresh
+ } else {
+ // the package was not loaded but should now be loaded
+ TRACE (_T("Loading package %s\n"), strMacroName);
+ try
+ {
+ GetCdlConfig()->load_package (CUtils::UnicodeToStdStr(strMacroName), CUtils::UnicodeToStdStr (strVersion), CConfigToolDoc::CdlParseErrorHandler, CConfigToolDoc::CdlParseWarningHandler);
+ bChanged=true;
+ }
+ catch (CdlStringException exception)
+ {
+ CUtils::MessageBoxF(_T("Error loading package %s:\n\n%s"), strMacroName, CString (exception.get_message ().c_str ()));
+ }
+ catch (...)
+ {
+ CUtils::MessageBoxF(_T("Error loading package %s."), strMacroName);
+ }
+ }
+ }
+ }
+
+ if (bChanged) {// at least one package was loaded, unloaded or changed version
+ SetModifiedFlag();
+ RegenerateData();
+ }
+ }
+}
+
+bool CConfigToolDoc::SetValue(CConfigItem &ti,ItemIntegerType nValue, CdlTransaction transaction/*=NULL*/)
+{
+ switch(ti.Type()){
+ case CConfigItem::Enum:
+ case CConfigItem::Integer:
+ // case CConfigItem::Boolean:
+ // case CConfigItem::Radio:
+ break;
+ case CConfigItem::None:
+ case CConfigItem::String:
+ default:
+ ASSERT(FALSE);
+ break;
+ }
+
+ bool rc=false;
+ bool bChangingMemmap=MemoryMap.map_modified () && ((ti.Macro ().Compare (_T ("CYG_HAL_STARTUP")) == 0));
+
+ if(nValue==ti.Value()){
+ return true;
+ }
+
+ // test if the new integer value is in range
+ if (CConfigItem::Integer == ti.Type ())
+ {
+ const CdlValuable valuable = ti.GetCdlValuable();
+ CdlListValue list_value;
+ CdlEvalContext context (NULL, ti.GetCdlItem (), ti.GetCdlItem ()->get_property (CdlPropertyId_LegalValues));
+ valuable->get_legal_values ()->eval (context, list_value);
+ if (! list_value.is_member ((cdl_int) nValue))
+ {
+ if (nValue==(ItemIntegerType) valuable->get_integer_value (CdlValueSource_Current) || IDNO == CUtils::MessageBoxFT (MB_YESNO, _T("%s is not a legal value for %s.\n\nDo you want to use this value anyway?"),
+ CUtils::IntToStr (nValue, CConfigTool::GetConfigToolDoc ()->m_bHex), ti.Macro ()))
+ goto Exit;
+ };
+ }
+
+ // if(!ti.CanSetValue(nValue))
+ // {
+ // if(bInteractive){
+ // CString strExplanation;
+ // if(CConfigItem::Integer==ti.Type()){
+ // strExplanation.Format(_T(" [value must lie in the range %d..%d]"),
+ // CUtils::IntToStr(ti.Min(),m_bHex),
+ // CUtils::IntToStr(ti.Max()),m_bHex);
+ // }
+ // CUtils::MessageBoxF(
+ // _T("Cannot set '%s' to %s%s"),
+ // ti.ItemNameOrMacro(), CUtils::IntToStr(nValue,m_bHex), strExplanation);
+ // }
+ // goto Exit;
+ // }
+
+ // warn the user if the current memory layout has been changed and will be lost
+ // this will happen when the layout has been modified and the target-platform-startup is changed
+
+ if (bChangingMemmap && IDCANCEL==CUtils::MessageBoxFT(MB_OKCANCEL,_T("Changes to the current memory layout will be lost."))){
+ goto Exit;
+ }
+
+ // Save state
+ if(!ti.SetValue(nValue,transaction)){
+ // CanSetValue above should have caught this
+ CUtils::MessageBoxF(_T("Cannot set '%s' to %d"),ti.ItemNameOrMacro(), nValue);
+ goto Exit;
+ }
+
+ rc=true;
+Exit:
+ if(rc){
+ SetModifiedFlag();
+ UpdateFailingRuleCount ();
+ UpdateAllViews (NULL, CConfigToolDoc::ValueChanged, (CObject *)&ti);
+ // switch to new memory layout when target, platform or startup changes
+ // but ignore cases where a target or platform is being deactivated (PR 19363)
+
+ // if (((CurrentTarget () != pOldTarget) || (CurrentPlatform () != strOldPlatform) || (ti.Name ().Compare (_T ("Startup type")) == 0)) &&
+ // ((ti.Type () != CConfigItem::Radio) || (nValue)))
+ // SwitchMemoryLayout ((CurrentTarget () != pOldTarget) || (CurrentPlatform () != strOldPlatform));
+ }
+ return rc;
+}
+
+bool CConfigToolDoc::OpenRepository(LPCTSTR pszRepository/*=NULL*/,bool bPromptInitially/*=false*/)
+{
+ if(!m_bRepositoryOpen){
+ CWaitCursor wait;
+ CIdleMessage IM(_T("Opening repository"));
+ UpdateFailingRuleCount();
+
+ CFileName strNewRepository;
+ while(!m_bRepositoryOpen){
+
+ if(bPromptInitially){
+ CFolderDialog dlg(/*BOOL bAllowCreation=*/false);
+ dlg.m_strDesc=_T("Please specify the root of the eCos repository tree.");
+ dlg.m_strTitle=_T("Choose folder for eCos repository");
+ dlg.m_strFolder=strNewRepository;
+ CConfigTool::DismissSplash();
+ if(IDCANCEL==dlg.DoModal()){
+ return false;
+ }
+ strNewRepository=dlg.m_strFolder;
+ } else {
+ // Use what came in as parameter or what was found in registry
+ strNewRepository=pszRepository?pszRepository:m_strRepository;
+ bPromptInitially=true;
+ }
+
+ IM.Set (_T("Opening repository ") + (CString) strNewRepository);
+
+ CdlPackagesDatabase NewCdlPkgData = NULL;
+ CdlInterpreter NewCdlInterp = NULL;
+ CdlConfiguration NewCdlConfig = NULL;
+ CFileName strNewPackagesDir;
+
+ EnableCallbacks(false); // disable transaction callbacks until the config tree is regenerated
+
+ if(OpenRepository(strNewRepository,NewCdlPkgData,NewCdlInterp,NewCdlConfig,strNewPackagesDir)){
+ // Success
+
+ // select the "default" template if it exists
+ // otherwise select the first available template
+ std::string default_template = "default";
+ if (! NewCdlPkgData->is_known_template (default_template))
+ {
+ const std::vector<std::string>& templates = NewCdlPkgData->get_templates ();
+ if (templates.size () != 0)
+ default_template = templates [0];
+ }
+
+ m_template_version = "";
+ try
+ {
+ const std::vector<std::string>& template_versions = NewCdlPkgData->get_template_versions (default_template);
+ NewCdlConfig->set_template (default_template, template_versions [0], &CdlParseErrorHandler, &CdlParseWarningHandler);
+ m_template_version = template_versions [0];
+ }
+ catch (CdlStringException exception) {
+ CUtils::MessageBoxF(_T("Error loading package template '%s':\n\n%s"), CString (default_template.c_str ()), CString (exception.get_message ().c_str ()));
+ }
+ catch (...) {
+ CUtils::MessageBoxF(_T("Error loading package template '%s'."), CString (default_template.c_str ()));
+ }
+
+ // check the configuration
+ ASSERT (NewCdlConfig->check_this (cyg_extreme));
+
+ // use the new package database, interpreter and configuration
+ deleteZ(m_CdlConfig); // delete the previous configuration
+ deleteZ(m_CdlInterp); // delete the previous interpreter
+ deleteZ(m_CdlPkgData); // delete the previous package database
+
+ m_CdlPkgData = NewCdlPkgData;
+ m_CdlInterp = NewCdlInterp;
+ m_CdlConfig = NewCdlConfig;
+
+ // save the repository location
+
+ SetRepository(strNewRepository);
+ m_strPackagesDir = strNewPackagesDir;
+
+#ifndef PLUGIN
+ // clear the previously specified document file name (if any),
+ // OnNewDocument() calls DeleteContents() so must be called
+ // before AddAllItems()
+ CDocument::OnNewDocument ();
+#endif
+
+ // generate the CConfigItems from their CDL descriptions
+ AddAllItems ();
+
+ m_bRepositoryOpen=true;
+ } else {
+ // failure
+ deleteZ(NewCdlConfig);
+ deleteZ(NewCdlInterp);
+ deleteZ(NewCdlPkgData);
+
+ }
+
+ // install a transaction handler callback function now that the tree exists
+ EnableCallbacks(true);
+ }
+
+ }
+ return m_bRepositoryOpen;
+}
+
+// Helper fn for namesake above
+bool CConfigToolDoc::OpenRepository (const CFileName strNewRepository,CdlPackagesDatabase &NewCdlPkgData,CdlInterpreter &NewCdlInterp,CdlConfiguration &NewCdlConfig,CFileName &strNewPackagesDir)
+{
+ bool rc=false;
+ TRACE(_T("###Open repository %s\n"),strNewRepository);
+ if(!strNewRepository.IsEmpty()){
+ // Now strNewRepository is guaranteed non-empty, but does it exist?
+ if(!strNewRepository.IsDir()) {
+ CUtils::MessageBoxF(_T("Cannot open repository - the folder %s does not exist"), strNewRepository);
+ } else {
+
+ // Ok so it exists, but does it look right?
+ strNewPackagesDir=strNewRepository+_T("ecc");
+ if(!strNewPackagesDir.IsDir()){
+ strNewPackagesDir=strNewRepository+_T("packages");
+ }
+
+ if(!strNewPackagesDir.IsDir()){
+ // Don't mention the ecc\ attempt
+ CUtils::MessageBoxF(_T("%s does not seem to be a source repository: the folder %s does not exist"),
+ strNewRepository,strNewPackagesDir);
+ } else {
+
+ const CFileName strDatabase = strNewPackagesDir + _T("ecos.db");
+ if(!strDatabase.Exists()) {
+ CUtils::MessageBoxF(_T("%s does not seem to be a source repository: %s does not exist"), strNewRepository, strDatabase);
+ } else {
+
+ // create a CDL repository, interpreter and configuration
+
+ try {// create a new package database, interpreter and configuration
+ NewCdlPkgData = CdlPackagesDatabaseBody::make (CUtils::UnicodeToStdStr(strNewPackagesDir), &CdlParseErrorHandler, &CdlParseWarningHandler);
+ NewCdlInterp = CdlInterpreterBody::make ();
+ NewCdlConfig = CdlConfigurationBody::make ("eCos", NewCdlPkgData, NewCdlInterp);
+ }
+ catch (CdlStringException exception) {
+ CUtils::MessageBoxF(_T("Error opening eCos repository:\n\n%s"), CString (exception.get_message ().c_str ()));
+ return false;
+ }
+ catch (...) {
+ CUtils::MessageBoxF(_T("Error opening eCos repository."));
+ return false;
+ }
+
+ // select the default target if specified in the registry
+ // otherwise select the first available target
+ std::string default_hardware = CUtils::UnicodeToStdStr (GetDefaultHardware ());
+ if (! NewCdlPkgData->is_known_target (default_hardware)) {
+ const std::vector<std::string>& targets = NewCdlPkgData->get_targets ();
+ if (targets.size () == 0){
+ CUtils::MessageBoxF (_T("Error opening eCos repository:\n\nno hardware templates"));
+ return false;
+ } else {
+ default_hardware = targets [0];
+ }
+ }
+
+ try {
+ m_strCdlErrorMessage = _T("");
+ NewCdlConfig->set_hardware (default_hardware, &CdlParseErrorHandler, &CdlParseWarningHandler);
+ }
+ catch (CdlStringException exception) {
+ if (m_strCdlErrorMessage.IsEmpty ())
+ {
+ CUtils::MessageBoxF (_T("Error loading the default hardware template '%s':\n\n%s"), CString (default_hardware.c_str ()), CString (exception.get_message ().c_str ()));
+ }
+ else // report the most recent parser message in the message box since there may be no output pane in which to view it
+ {
+ CUtils::MessageBoxF (_T("Error loading the default hardware template '%s':\n\n%s\n\nParser message:\n\n%s"), CString (default_hardware.c_str ()), CString (exception.get_message ().c_str ()), m_strCdlErrorMessage);
+ }
+ return false;
+ }
+ catch (...) {
+ CUtils::MessageBoxF (_T("Error loading the default hardware template '%s':\n\n%s"), CString (default_hardware.c_str ()), m_strCdlErrorMessage);
+ return false;
+ }
+ rc=true;
+ }
+ }
+ }
+ }
+ return rc;
+}
+
+void CConfigToolDoc::CloseRepository()
+{
+ if(m_bRepositoryOpen){
+ // delete the libCDL objects with the document
+ EnableCallbacks(false); // first disable the transaction handler
+ deleteZ(m_CdlConfig);
+ deleteZ(m_CdlInterp);
+ deleteZ(m_CdlPkgData);
+ m_bRepositoryOpen=false;
+ }
+}
+
+void CConfigToolDoc::SelectTemplate (std::string NewTemplate, std::string NewTemplateVersion)
+{
+ if ((NewTemplate != m_CdlConfig->get_template()) || (NewTemplateVersion != m_template_version)){
+
+ CWaitCursor wait; // this may take a little while
+ RemoveAllItems();
+ m_template_version = "";
+ try
+ {
+ m_CdlConfig->set_template (NewTemplate, NewTemplateVersion, CdlParseErrorHandler, CdlParseWarningHandler);
+ m_template_version = NewTemplateVersion;
+ }
+ catch (CdlStringException exception)
+ {
+ CUtils::MessageBoxF(_T("Error loading package template '%s':\n\n%s"), CString (NewTemplate.c_str ()), CString (exception.get_message ().c_str ()));
+ }
+ catch (...)
+ {
+ CUtils::MessageBoxF(_T("Error loading package template '%s'."), CString (NewTemplate.c_str ()));
+ }
+ RegenerateData();
+
+ if (!GetPathName().IsEmpty()){ // not a new document
+ CopyMLTFiles (); // copy new MLT files to the build tree as necessary
+ }
+ SetModifiedFlag();
+ }
+}
+
+void CConfigToolDoc::RegenerateData()
+{
+ CWaitCursor wait; // This may take a little while
+ AddAllItems (); // regenerate all the config items since the topology may have changed
+ if (m_strLinkerScriptFolder.IsEmpty ())
+ {
+ CUtils::MessageBoxF(_T("The eCos linker script macro CYGBLD_LINKER_SCRIPT is not defined."));
+ }
+ if (m_strMemoryLayoutFolder.IsEmpty ())
+ {
+ CUtils::MessageBoxF(_T("The eCos memory layout macro CYGHWR_MEMORY_LAYOUT is not defined."));
+ }
+ SwitchMemoryLayout (true); // the hardware template may have changed
+ UpdateBuildInfo();
+ CConfigTool::GetControlView()->SelectItem(Item(0));
+}
+
+void CConfigToolDoc::SelectHardware (std::string NewTemplate)
+{
+ const std::string OldTemplate=m_CdlConfig->get_hardware();
+ if (NewTemplate != OldTemplate){
+ RemoveAllItems();
+
+ try
+ {
+ m_CdlConfig->set_hardware (NewTemplate, CdlParseErrorHandler, CdlParseWarningHandler);
+ }
+ catch (CdlStringException exception)
+ {
+ CUtils::MessageBoxF(_T("Error loading hardware template '%s':\n\n%s"), CString (NewTemplate.c_str ()), CString (exception.get_message ().c_str ()));
+ m_CdlConfig->set_hardware (OldTemplate, CdlParseErrorHandler, CdlParseWarningHandler);
+ }
+ catch (...)
+ {
+ CUtils::MessageBoxF(_T("Error loading hardware template '%s'."), CString (NewTemplate.c_str ()));
+ m_CdlConfig->set_hardware (OldTemplate, CdlParseErrorHandler, CdlParseWarningHandler);
+ }
+
+ RegenerateData();
+ //EnableCallbacks(true); // re-enable the transaction handler
+ if (!GetPathName().IsEmpty()){
+ CopyMLTFiles (); // copy new MLT files to the build tree as necessary
+ }
+ SetModifiedFlag();
+ }
+}
+
+bool CConfigToolDoc::SaveMemoryMap()
+{
+ const CString strSuffix(_T("mlt_") + CurrentMemoryLayout ());
+ const CFileName strMLTInstallPkgconfDir(InstallTree() + _T("include\\pkgconf"));
+ bool rc=false;
+ if(strMLTInstallPkgconfDir.CreateDirectory(true)){
+ const CString strMLTInstallBase(strMLTInstallPkgconfDir+CFileName(strSuffix));
+ const CFileName strMLTDir (MLTDir());
+ if(strMLTDir.CreateDirectory (true)){
+ const CString strMLTBase (strMLTDir + CFileName (strSuffix));
+ TRACE(_T("Saving memory layout to %s\n"), strMLTBase + _T(".mlt"));
+ if(MemoryMap.save_memory_layout (strMLTBase + _T(".mlt"))){
+ TRACE(_T("Exporting memory layout to %s\n"), strMLTInstallPkgconfDir);
+ rc=MemoryMap.export_files (strMLTInstallBase + _T(".ldi"), strMLTInstallBase + _T(".h"));
+ }
+ }
+ }
+ return rc;
+}
+
+bool CConfigToolDoc::CopyMLTFiles()
+{
+ // copy default MLT files for the selected target/platform from the repository if they do not already exist
+
+ TRACE (_T("Looking for MLT files at %s\n"), PackagesDir() + m_strMemoryLayoutFolder + _T("include\\pkgconf\\mlt_*.*"));
+ const CFileName strInstallDestination(InstallTree () + _T("include\\pkgconf"));
+ const CFileName strMLTDestination (MLTDir ());
+ TRACE (_T("Copying .ldi and .h files to %s\n"), strInstallDestination);
+ TRACE (_T("Copying .mlt files to %s\n"), strMLTDestination);
+ bool rc=strInstallDestination.CreateDirectory (true) && strMLTDestination.CreateDirectory (true);
+ if(rc){
+ CFileFind ffFileFind;
+ BOOL bLastFile = ffFileFind.FindFile (PackagesDir() + m_strMemoryLayoutFolder + _T("\\include\\pkgconf\\mlt_*.*"));
+ while (bLastFile)
+ {
+ bLastFile = ffFileFind.FindNextFile ();
+ if (_T(".mlt") == ffFileFind.GetFileName ().Right (4)) // if a .mlt file
+ {
+ if (! CFileName (strMLTDestination, CFileName (ffFileFind.GetFileName ())).Exists ())
+ {
+ if(!CUtils::CopyFile (ffFileFind.GetFilePath (), strMLTDestination + CFileName (ffFileFind.GetFileName ()))){
+ return false; // message already emitted
+ }
+ }
+ }
+ else // a .h or .ldi file
+ {
+ if (! CFileName (strInstallDestination, CFileName (ffFileFind.GetFileName ())).Exists () &&
+ !CUtils::CopyFile (ffFileFind.GetFilePath (), strInstallDestination + CFileName (ffFileFind.GetFileName ()))){
+ return false; // message already emitted
+ }
+ }
+ }
+ }
+ return rc; //FIXME
+}
+
+CString CConfigToolDoc::GetDefaultHardware ()
+{
+ CString strKey = _T("SOFTWARE\\Red Hat\\eCos");
+ CString strVersionKey = _T("");
+ CString rc = _T("");
+ TCHAR pszBuffer [MAX_PATH + 1];
+ HKEY hKey;
+ LONG lStatus;
+
+ // get the greatest eCos version subkey
+ if (ERROR_SUCCESS == RegOpenKeyEx (HKEY_LOCAL_MACHINE, strKey, 0L, KEY_READ, &hKey))
+ {
+ DWORD dwIndex = 0;
+ while (ERROR_SUCCESS == RegEnumKey (hKey, dwIndex++, (LPTSTR) pszBuffer, sizeof (pszBuffer)))
+ {
+ if (strVersionKey.Compare (pszBuffer) < 0)
+ strVersionKey = pszBuffer;
+ }
+ RegCloseKey (hKey);
+ if (! strVersionKey.IsEmpty ())
+ {
+ TRACE (_T("CConfigToolDoc::GetDefaultHardware(): version subkey = '%s'\n"), strVersionKey);
+
+ // get the default hardware value
+ strKey += _T("\\") + strVersionKey;
+ if (ERROR_SUCCESS == RegOpenKeyEx (HKEY_LOCAL_MACHINE, strKey, 0L, KEY_READ, &hKey))
+ {
+ DWORD dwBufferSize = sizeof (pszBuffer);
+ lStatus = RegQueryValueEx (hKey, _T("Default Hardware"), NULL, NULL, (LPBYTE) pszBuffer, &dwBufferSize);
+ RegCloseKey (hKey);
+ if (ERROR_SUCCESS == lStatus)
+ {
+ TRACE (_T("CConfigToolDoc::GetDefaultHardware(): default hardware = '%s'\n"), pszBuffer);
+ rc=pszBuffer;
+ }
+ }
+ }
+ }
+ return rc;
+}
+
+CConfigItem * CConfigToolDoc::AddItem (const CdlUserVisible vitem, CConfigItem * pParent)
+{
+ CConfigItem * pItem = new CConfigItem (pParent, vitem);
+
+ m_arItem.Add(pItem);
+ pItem->m_strDesc = CUtils::StripExtraWhitespace (CString (vitem->get_description ().c_str ()));
+
+ if (vitem->get_name () == "CYGHWR_MEMORY_LAYOUT")
+ {
+ ASSERT (m_strMemoryLayoutFolder.IsEmpty ());
+ m_strMemoryLayoutFolder = vitem->get_owner ()->get_directory().c_str ();
+ m_strMemoryLayoutFolder.Replace(_TCHAR('/'),_TCHAR('\\'));
+ TRACE (_T("Found memory layout folder: %s\n"), m_strMemoryLayoutFolder);
+ }
+
+ if (vitem->get_name () == "CYGBLD_LINKER_SCRIPT")
+ {
+ ASSERT (m_strLinkerScriptFolder.IsEmpty ());
+ m_strLinkerScriptFolder = vitem->get_owner ()->get_directory().c_str ();
+ m_strLinkerScriptFolder.Replace(_TCHAR('/'),_TCHAR('\\'));
+ TRACE (_T("Found linker script folder: %s\n"), m_strLinkerScriptFolder);
+
+ // the CDL hardware template name will eventually become the target name,
+ // but for now we must deduce the target name from the linker script file name
+
+ const CdlValuable valuable = dynamic_cast<CdlValuable> (vitem);
+ CFileName strLinkerScript (m_strPackagesDir, m_strLinkerScriptFolder, CString (valuable->get_value ().c_str ()));
+ strLinkerScript.Replace (_TCHAR('/'), _TCHAR('\\'));
+ if(!strLinkerScript.Exists ()){
+ CConfigTool::Log(_T("%s does not exist\n"),strLinkerScript);
+ }
+ TRACE (_T("Target '%s' selected\n"), strLinkerScript.Tail ().Root (), pItem->Macro());
+ //CFileName strBinDir = AfxGetApp () -> GetProfileString (CUtils::LoadString (IDS_KEY_TOOLS_DIR), pTarget->Name (), _T(""));
+ //if (! strBinDir.IsEmpty () && strBinDir.IsDir ())
+ //{
+ // pTarget->SetBinDir (strBinDir);
+ //}
+ }
+
+ //TRACE(_T("Created new item from cdl: "));
+ //pItem->DumpItem();
+ return pItem;
+}
+
+void CConfigToolDoc::AddAllItems ()
+{
+ // remove any old items and packages
+ DeleteContents ();
+ if(NULL!=CConfigTool::GetControlView()){ // may not be the case for plugin
+
+ // add the root item
+ CConfigItem * pItem = new CConfigItem (NULL, NULL);
+ m_arItem.Add(pItem);
+ pItem->m_strDesc = _T("The root node for all configurable items");
+
+ // add the remaining items using their CDL descriptions
+ m_strMemoryLayoutFolder = _T("");
+ m_strLinkerScriptFolder = _T("");
+ AddContents (m_CdlConfig, FirstItem ());
+
+ // check that exactly one radio button in each group is enabled
+ CheckRadios ();
+
+ // update the rules (conflicts) view
+ UpdateFailingRuleCount ();
+
+ if(NULL==CConfigTool::GetRulesView() || !CConfigTool::GetRulesView()->IsWindowVisible()){
+ // log all conflicts
+ // LogConflicts (m_CdlConfig->get_structural_conflicts ()); // relating to package availability - ignore for now
+ LogConflicts (m_CdlConfig->get_all_conflicts ());
+ }
+
+ CConfigTool::GetControlView()->SelectItem(Item(0));
+ UpdateAllViews (NULL, SelChanged, (CObject *)Item(0)); // refresh the display
+ if(ItemCount()>0){
+ CConfigTool::GetControlView()->GetTreeCtrl().Expand(Item(0)->HItem(),TVE_EXPAND);
+ }
+ CConfigTool::GetControlView()->SetFocus();
+ }
+}
+
+const CFileName CConfigToolDoc::CurrentLinkerScript()
+{
+ const CConfigItem * pItem = Find (_T("CYGBLD_LINKER_SCRIPT"));
+ return pItem ? CFileName (m_strPackagesDir, m_strLinkerScriptFolder, pItem->StringValue ()) : _T("");
+}
+
+bool CConfigToolDoc::GenerateHeaders()
+{
+// Copy non-config header files from the repository to the
+// install tree for plugin only. The make system used by
+// the standalone config tool does this for us.
+#ifdef PLUGIN
+ typedef std::vector<CdlBuildInfo_Loadable> EntriesArray;
+ const EntriesArray &arEntries=BuildInfo().entries;
+ typedef std::vector<CdlBuildInfo_Header> HeaderArray;
+ for(EntriesArray::size_type j=0;j<arEntries.size();j++){
+ const CdlBuildInfo_Loadable &e=arEntries[j];
+ const CFileName strDir(CUtils::WPath(e.directory));
+ const HeaderArray &arHeaders=e.headers;
+ for(HeaderArray::size_type i=0;i<arHeaders.size();i++){
+ const CdlBuildInfo_Header &h=arHeaders[i];
+ const CFileName strSource(PackagesDir()+strDir+CUtils::WPath(h.source));
+ const CFileName strDest(HeadersDir()/*+CUtils::WPath(e.directory)*/+CUtils::WPath(h.destination));
+
+ if(!strDest.Head().CreateDirectory(true)){
+ CUtils::MessageBoxF(_T("Failed to create %s - %s"),strDest.Head(),CUtils::GetLastErrorMessageString());
+ return false;
+ }
+ if(!CUtils::CopyFile(strSource,strDest)){
+ return false; // message already emitted
+ }
+ }
+ }
+#endif
+
+ // Generate headers
+ try {
+ CFileName strPkfConfDir(InstallTree()+_T("include\\pkgconf"));
+ if(!strPkfConfDir.CreateDirectory()){
+ CUtils::MessageBoxF(_T("Failed to create %s - %s"),strPkfConfDir,CUtils::GetLastErrorMessageString());
+ return false;
+ }
+ GetCdlConfig()->generate_config_headers(CUtils::UnicodeToStdStr(strPkfConfDir.ShortName()));
+ }
+ catch (CdlInputOutputException e) {
+ const CString strMsg(e.get_message().c_str());
+ TRACE(_T("!!! Exception thrown calling generate_config_headers - %s"),strMsg);
+ CUtils::MessageBoxF(_T("Failed to generate header files - %s"),strMsg);
+ return false;
+ }
+ return true;
+}
+
+const CFileName CConfigToolDoc::MLTDir ()
+{
+ CString strPathName (GetPathName ());
+ ASSERT (! strPathName.IsEmpty ());
+ return strPathName.Left (strPathName.ReverseFind (_TCHAR('.'))) + _T("_mlt");
+}
+
+bool CConfigToolDoc::UpdateBuildInfo(bool bFirstTime)
+{
+ try {
+ GetCdlConfig()->get_build_info(m_BuildInfo);
+ #ifdef PLUGIN
+ // FIXME: this means anything not mentioned by AddFile in our scan below will be removed - including user-added items
+ m_peCosProject->ClearItemFlags();
+ m_peCosProject->UpdateeCosProject(bFirstTime);
+ m_peCosProject->RemoveAllUnflaggedItems();
+ #else
+ UNUSED_ALWAYS(bFirstTime);
+ generate_build_tree (GetCdlConfig(), CUtils::UnicodeToStdStr(BuildTree()), CUtils::UnicodeToStdStr(InstallTree()));
+ #endif
+ return true;
+ }
+ catch(...){
+ return false;
+ }
+}
+
+void CConfigToolDoc::RemoveAllItems()
+{
+ for(int nItem=0;nItem<ItemCount();nItem++){
+ CConfigItem *pItem=Item(nItem);
+ deleteZ(pItem);
+ }
+ m_arItem.RemoveAll();
+
+ UpdateAllViews(NULL,Clear,0);
+}
+
+void CConfigToolDoc::EnableCallbacks (bool bEnable/*=true*/)
+{
+ CdlTransactionCallback::set_callback_fn(bEnable?&CdlTransactionHandler:0);
+ CdlTransactionBody::set_inference_callback_fn(bEnable?&CdlInferenceHandler:0);
+ CdlTransactionBody::set_inference_override(CdlValueSource_Invalid);
+}
+
+int CConfigToolDoc::GetTestExeNames (CFileNameArray &arTestExes,CFileNameArray &arMissing)
+{
+ arTestExes.RemoveAll();
+ arMissing.RemoveAll();
+
+ typedef std::vector<CdlBuildInfo_Loadable> EntriesArray;
+ const EntriesArray &arEntries=BuildInfo().entries;
+ for(EntriesArray::size_type j=0;j<arEntries.size();j++){
+ const CdlBuildInfo_Loadable &e=arEntries[j];
+ CStringArray ar;
+ int n=CUtils::Chop(CString(get_tests(GetCdlConfig(),e).c_str()),ar);
+ for(int i=0;i<n;i++){
+ CFileName strFile;
+ strFile.Format(_T("%s\\tests\\%s\\%s.exe"),InstallTree(),CString(e.directory.c_str()),ar[i]);
+ strFile.Replace(_TCHAR('/'),_TCHAR('\\'));
+ if(strFile.Exists()){
+ arTestExes.Add(strFile);
+ } else {
+ arMissing.Add(strFile);
+ }
+ }
+ }
+ return arTestExes.GetSize();
+}
+
+CConfigToolDoc::GlobalConflictOutcome CConfigToolDoc::ResolveGlobalConflicts(CPtrArray *parConflictsOfInterest)
+{
+ m_ConflictsOutcome=NotDone;
+ m_arConflictsOfInterest.RemoveAll();
+ if(parConflictsOfInterest){
+ m_arConflictsOfInterest.Copy(*parConflictsOfInterest);
+ }
+ CdlInferenceCallback fn=CdlTransactionBody::get_inference_callback_fn();
+ CdlTransactionBody::set_inference_callback_fn(CdlGlobalInferenceHandler);
+ GetCdlInterpreter()->get_toplevel()->resolve_all_conflicts();
+ CdlTransactionBody::set_inference_callback_fn(fn);
+ if(NotDone==m_ConflictsOutcome){
+ // No solutions were available, but we'll run the dialog anyway
+ const std::list<CdlConflict>& conflicts=GetCdlConfig()->get_all_conflicts();
+ CFailingRulesDialog dlg(conflicts,NULL,&m_arConflictsOfInterest);
+ m_ConflictsOutcome=(IDOK==dlg.DoModal())?OK:Cancel;
+ }
+ return m_ConflictsOutcome;
+}
+
+bool CConfigToolDoc::CheckConflictsBeforeSave()
+{
+ if(GetCdlInterpreter()->get_toplevel()->get_all_conflicts().size()>0){
+ if(Deferred&m_nRuleChecking){
+ if((SuggestFixes&m_nRuleChecking)&&(Cancel==ResolveGlobalConflicts())){
+ return false;
+ }
+ int nConflicts=GetCdlInterpreter()->get_toplevel()->get_all_conflicts().size();
+ switch(nConflicts){
+ case 0:
+ break;
+ case 1:
+ if(IDNO==CUtils::MessageBoxFT(MB_YESNO|MB_DEFBUTTON2,_T("There is 1 unresolved conflict. Save anyway?"))){
+ return false;
+ }
+ default:
+ if(IDNO==CUtils::MessageBoxFT(MB_YESNO|MB_DEFBUTTON2,_T("There are %d unresolved conflicts. Save anyway?"),nConflicts)){
+ return false;
+ }
+ }
+ }
+ }
+ return true;
+}
+
+BOOL CConfigToolDoc::IsModified()
+{
+ return m_bModified || MemoryMap.map_modified();
+}
+
+void CConfigToolDoc::OnFileExport()
+{
+ CFileDialog dlg (FALSE, _T("ecm"), NULL, OFN_OVERWRITEPROMPT | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY, _T("eCos Minimal Configuration (*.ecm)|*.ecm||"), AfxGetMainWnd ());
+ TCHAR szBuffer [MAX_PATH * 16] = _T("");
+ dlg.m_ofn.lpstrFile = szBuffer;
+ dlg.m_ofn.nMaxFile = MAX_PATH * 16;
+ dlg.m_ofn.lpstrTitle = _T("Export eCos Minimal Configuration");
+ if (IDOK == dlg.DoModal ()) {
+ try {
+ TRACE (_T("Exporting eCos minimal configuration '%s'\n"), dlg.GetPathName ());
+ m_CdlConfig->save (CUtils::UnicodeToStdStr (dlg.GetPathName ()), /* minimal = */ true);
+ }
+ catch (CdlStringException exception) {
+ CUtils::MessageBoxF (_T("Error exporting eCos minimal configuration:\n\n%s"), CString (exception.get_message ().c_str ()));
+ }
+ catch (...) {
+ CUtils::MessageBoxF (_T("Error exporting eCos minimal configuration."));
+ }
+ }
+}
+
+void CConfigToolDoc::OnFileImport()
+{
+ CFileDialog dlg (TRUE, _T("ecm"), NULL, OFN_PATHMUSTEXIST | OFN_HIDEREADONLY, _T("eCos Minimal Configurations (*.ecm)|*.ecm||"), AfxGetMainWnd ());
+ TCHAR szBuffer [MAX_PATH * 16] = _T("");
+ dlg.m_ofn.lpstrFile = szBuffer;
+ dlg.m_ofn.nMaxFile = MAX_PATH * 16;
+ dlg.m_ofn.lpstrTitle = _T("Import eCos Minimal Configuration");
+ if (IDOK == dlg.DoModal ()) {
+ try {
+ TRACE (_T("Importing eCos minimal configuration '%s'\n"), dlg.GetPathName ());
+ m_CdlConfig->add (CUtils::UnicodeToStdStr (dlg.GetPathName ()), CConfigToolDoc::CdlParseErrorHandler, CConfigToolDoc::CdlParseWarningHandler);
+ }
+ catch (CdlStringException exception) {
+ CUtils::MessageBoxF (_T("Error importing eCos minimal configuration:\n\n%s"), CString (exception.get_message ().c_str ()));
+ }
+ catch (...) {
+ CUtils::MessageBoxF (_T("Error importing eCos minimal configuration."));
+ }
+
+ CWaitCursor wait;
+ AddAllItems (); // regenerate all the config items since the topology may have changed
+ if (m_strLinkerScriptFolder.IsEmpty ()) {
+ CUtils::MessageBoxF (_T("The eCos linker script macro CYGBLD_LINKER_SCRIPT is not defined."));
+ }
+ if (m_strMemoryLayoutFolder.IsEmpty ()) {
+ CUtils::MessageBoxF (_T("The eCos memory layout macro CYGHWR_MEMORY_LAYOUT is not defined."));
+ }
+ SwitchMemoryLayout (true); // the hardware template may have changed
+ UpdateBuildInfo ();
+ CConfigTool::GetControlView()->SelectItem (Item (0));
+ SetModifiedFlag ();
+ }
+}
+
+bool CConfigToolDoc::QualifyDocURL(CString &strURL)
+{
+ if(-1==strURL.Find(_T("://"))){
+ strURL.Replace(_TCHAR('/'),_TCHAR('\\'));
+ if (! CFileName (strURL).IsFile ()) { // if not an absolute filepath
+ strURL = DocBase () + CFileName (strURL); // prepend the doc directory path
+ }
+ strURL=_T("file://")+strURL;
+ }
+
+ if(0==strURL.Find(_T("file://"))){
+ CFileName strFile(strURL.Right(strURL.GetLength()-7));
+ int nIndex=strFile.ReverseFind(_TCHAR('#'));
+ if(-1!=nIndex){
+ strFile=strFile.Left(nIndex);
+ }
+ strFile.Replace(_TCHAR('/'),_TCHAR('\\'));
+ if(!strFile.Exists()){
+ CUtils::MessageBoxF(_T("Cannot locate the file %s"),strFile);
+ return false;
+ }
+ }
+ return true;
+}
+
+bool CConfigToolDoc::NewMemoryLayout (const CString &strPrefix)
+{
+ CFileName strFileName = CurrentLinkerScript ();
+ TRACE(_T("Reading linker-defined memory sections from %s\n"), strFileName);
+ MemoryMap.new_memory_layout (); // delete the old memory layout regardless
+ if (! strFileName.IsEmpty ())
+ MemoryMap.import_linker_defined_sections (strFileName); // read the linker-defined section names from the repository (failure is silent)
+
+ CString strMemoryLayoutFileName = strPrefix + _T("\\mlt_") + CurrentMemoryLayout () + _T(".mlt");
+ TRACE(_T("Reading memory layout from %s\n"), strMemoryLayoutFileName);
+ MemoryMap.load_memory_layout (strMemoryLayoutFileName); // load the new memory layout (failure is silent)
+ strSelectedSection = _T("");
+ strSelectedRegion = _T("");
+ UpdateAllViews (NULL, MemLayoutChanged);
+ return true; // FIXME
+}
+
+void CConfigToolDoc::SetPathName( LPCTSTR pszPath, BOOL bAddToMRU /*= TRUE*/ )
+{
+ if(_TCHAR('\0')==*pszPath){ // called like this after failed saves to put things back as they were
+ // CDocument::SetPathName would assert given an empty string
+ m_strPathName = _T("");
+#ifndef PLUGIN
+ SetTitle(_T("Untitled"));
+#endif
+ m_strBuildTree = _T("");
+ m_strInstallTree = _T("");
+ } else {
+#ifdef PLUGIN
+ m_strPathName = CFileName (pszPath);
+#else
+ CDocument::SetPathName (pszPath, bAddToMRU);
+#endif
+ CString strFolder (pszPath);
+ strFolder = strFolder.Left (strFolder.ReverseFind (_TCHAR('.'))); // extract folder from file path
+ m_strBuildTree = CFileName(strFolder + _T("_build"));
+ m_strInstallTree = CFileName(strFolder + _T("_install"));
+ }
+}
+
+bool CConfigToolDoc::ShowHtmlHelp (LPCTSTR pszURL)
+{
+
+ HWND hwndCaller=AfxGetMainWnd()->CWnd::GetDesktopWindow()->GetSafeHwnd();
+ bool rc=false;
+ const CFileName strFile(HTMLHelpLinkFileName());
+ CStdioFile f;
+ if(!CFileName(CConfigTool::strHelpFile).Exists()) {
+ CUtils::MessageBoxF(_T("Cannot display help - %s does not exist\n"),CConfigTool::strHelpFile);
+ } else if(!f.Open(strFile,CFile::typeText|CFile::modeCreate|CFile::modeWrite)){
+ CUtils::MessageBoxF(_T("Cannot display help - error creating %s\n"),strFile);
+ } else {
+ CString str;
+ str.Format(_T("<meta HTTP-EQUIV=\"refresh\" CONTENT=\"0;URL=%s\">"),pszURL);
+ f.WriteString(str);
+ f.Close();
+ if(0==HtmlHelp(hwndCaller, CConfigTool::strHelpFile, HH_DISPLAY_TOPIC, 0)){
+ CUtils::MessageBoxF(_T("Cannot display %s"),pszURL);
+ } else {
+ // FIXME: Do this the first time only?
+ HH_WINTYPE WinType;
+ HWND wnd;
+ HH_WINTYPE *pWinType=NULL;
+ wnd = HtmlHelp(hwndCaller, CConfigTool::strHelpFile+_T(">mainwin"), HH_GET_WIN_TYPE, (DWORD) &pWinType);
+ WinType=*pWinType;
+ WinType.hwndCaller=hwndCaller;
+ WinType.fsWinProperties|=HHWIN_PROP_TRACKING;
+ WinType.idNotify = ID_HHNOTIFICATION;
+ wnd = HtmlHelp(hwndCaller, CConfigTool::strHelpFile, HH_SET_WIN_TYPE, (DWORD) &WinType);
+ rc=true;
+ }
+ //::DeleteFile(strFile);
+ }
+ return rc;
+}
+
+const CString CConfigToolDoc::HTMLHelpLinkFileName()
+{
+ return CFileName(CConfigTool::strHelpFile).Head()+"link2.htm";
+}
projects / karo-tx-redboot.git / blobdiff