You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4981 lines
140 KiB
4981 lines
140 KiB
// INFWizrd.cpp : implementation file
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "minidev.h"
|
|
#include <gpdparse.h>
|
|
#include "rcfile.h"
|
|
#include "projrec.h"
|
|
#include "projview.h"
|
|
#include "comctrls.h"
|
|
#include "Gpdview.h" //RAID 0001
|
|
#include "INFWizrd.h"
|
|
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizard
|
|
|
|
IMPLEMENT_DYNAMIC(CINFWizard, CPropertySheet)
|
|
|
|
CINFWizard::CINFWizard(CWnd* pParentWnd, UINT iSelectPage)
|
|
: CPropertySheet(IDS_INFWizTitle, pParentWnd ) //iSelectPage ) RAID 0001//Welcome page should be top even iselectpage=1
|
|
{
|
|
// Save parent pointer
|
|
|
|
m_pcpvParent = (CProjectView*) pParentWnd ;
|
|
|
|
// Give the pages a pointer to the sheet.
|
|
|
|
m_ciww.m_pciwParent = this ;
|
|
m_ciwm.m_pciwParent = this ;
|
|
m_ciwgpi.m_pciwParent = this ;
|
|
m_ciwbd.m_pciwParent = this ;
|
|
m_ciwip.m_pciwParent = this ;
|
|
m_ciwif.m_pciwParent = this ;
|
|
m_ciwis.m_pciwParent = this ;
|
|
m_ciwds.m_pciwParent = this ;
|
|
m_ciwef.m_pciwParent = this ;
|
|
m_ciwmn.m_pciwParent = this ;
|
|
m_ciwnse.m_pciwParent = this ;
|
|
m_ciwnsms.m_pciwParent = this ;
|
|
m_ciws.m_pciwParent = this ;
|
|
|
|
// Add the wizard's pages and set wizard moede.
|
|
|
|
AddPage(&m_ciww) ;
|
|
AddPage(&m_ciwm) ;
|
|
AddPage(&m_ciwgpi) ;
|
|
AddPage(&m_ciwbd) ;
|
|
AddPage(&m_ciwip) ;
|
|
AddPage(&m_ciwif) ;
|
|
AddPage(&m_ciwis) ;
|
|
AddPage(&m_ciwds) ;
|
|
AddPage(&m_ciwef) ;
|
|
AddPage(&m_ciwmn) ;
|
|
AddPage(&m_ciwnse) ;
|
|
AddPage(&m_ciwnsms) ;
|
|
AddPage(&m_ciws) ;
|
|
SetWizardMode() ;
|
|
|
|
// Get and save a pointer to the project record (document) class associated
|
|
// with this class' parent.
|
|
|
|
if(NULL != iSelectPage ){ //RAID 0001
|
|
CGPDViewer* pcgv = (CGPDViewer*) m_pcpvParent;
|
|
m_pcgc = pcgv ->GetDocument();
|
|
}
|
|
else{ // END RAID
|
|
m_pcpr = (CProjectRecord*) m_pcpvParent->GetDocument() ;
|
|
m_pcgc = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
CINFWizard::~CINFWizard()
|
|
{
|
|
}
|
|
|
|
|
|
unsigned CINFWizard::GetModelCount()
|
|
{
|
|
if(m_pcgc) //RAID 0001
|
|
return 1; // only one gpdviewer
|
|
else //END RAID
|
|
return m_pcpr->ModelCount() ;
|
|
}
|
|
|
|
|
|
CModelData& CINFWizard::GetModel(unsigned uidx)
|
|
{
|
|
return m_pcpr->Model(uidx) ;
|
|
}
|
|
|
|
|
|
void CINFWizard::SetFixupFlags()
|
|
{
|
|
// Set flags in each of the pages that need to update their data and UI when
|
|
// the selected models change.
|
|
|
|
m_ciwgpi.m_bSelChanged = true ;
|
|
m_ciwbd.m_bSelChanged = true ;
|
|
m_ciwip.m_bSelChanged = true ;
|
|
m_ciwif.m_bSelChanged = true ;
|
|
m_ciwis.m_bSelChanged = true ;
|
|
m_ciwds.m_bSelChanged = true ;
|
|
m_ciwef.m_bSelChanged = true ;
|
|
m_ciwnsms.m_bSelChanged = true ;
|
|
}
|
|
|
|
|
|
void CINFWizard::BiDiDataChanged()
|
|
{
|
|
// If the selected models' BiDi data may have changed, call the pages that
|
|
// maintain related data so that they can update their data when/if needed.
|
|
|
|
m_ciwis.BiDiDataChanged() ;
|
|
m_ciwds.BiDiDataChanged() ;
|
|
}
|
|
|
|
|
|
void CINFWizard::NonStdSecsChanged()
|
|
{
|
|
// If the nonstandard sections may have changed, call the pages that
|
|
// maintain related data so that they can update their data when/if needed.
|
|
|
|
m_ciwnsms.NonStdSecsChanged() ;
|
|
}
|
|
|
|
|
|
bool CINFWizard::GenerateINFFile()
|
|
{
|
|
// This might take a while, so...
|
|
|
|
CWaitCursor cwc ;
|
|
|
|
// Mark all of the sections in the "section used in INF file flags" array
|
|
// as NOT having been used.
|
|
|
|
unsigned unumelts = (unsigned)m_ciwnse.m_cuaSecUsed.GetSize() ;
|
|
for (unsigned u = 0 ; u < unumelts ; u++)
|
|
m_ciwnse.m_cuaSecUsed[u] = false ;
|
|
|
|
// Initialize the source disk files array.
|
|
|
|
m_csaSrcDskFiles.RemoveAll() ;
|
|
|
|
// Start by loading the string with the INF's opening comment header.
|
|
|
|
m_csINFContents.LoadString(IDS_INFText_HeaderCmt) ;
|
|
|
|
// Add the version section with the appropriate value for the provider.
|
|
|
|
CString cs ;
|
|
cs.Format(IDS_INFText_Version, m_ciwmn.m_csMfgAbbrev) ;
|
|
ChkForNonStdAdditions(cs, _T("Version")) ;
|
|
m_csINFContents += cs ;
|
|
|
|
// Add the ClassInstall32.NT and printer_class_addreg sections plus the
|
|
// comments for the manufacturer's section.
|
|
|
|
cs.LoadString(IDS_INFText_ClInst32) ;
|
|
ChkForNonStdAdditions(cs, _T("ClassInstall32.NT")) ;
|
|
m_csINFContents += cs ;
|
|
cs.LoadString(IDS_INFText_PCAddr) ;
|
|
ChkForNonStdAdditions(cs, _T("printer_class_addreg")) ;
|
|
m_csINFContents += cs ;
|
|
cs.LoadString(IDS_INFText_MfgCmt) ;
|
|
m_csINFContents += cs ;
|
|
|
|
// Add the manufacturer's name to the manufacturer's section and add the
|
|
// section.
|
|
|
|
cs.Format(IDS_INFText_Manufacturer, m_ciwmn.m_csMfgName) ;
|
|
ChkForNonStdAdditions(cs, _T("Manufacturer")) ;
|
|
m_csINFContents += cs ;
|
|
|
|
// Build the model specifications section and add the section.
|
|
|
|
BldModSpecSec(m_csINFContents) ;
|
|
|
|
// Build the copy file sections and add them to the INF contents.
|
|
|
|
BuildInstallAndCopySecs(m_csINFContents) ;
|
|
|
|
// Add the DestinationDirs section to the INF contents.
|
|
|
|
cs.LoadString(IDS_INFText_DestDirs) ;
|
|
AddICMFilesToDestDirs(cs) ;
|
|
ChkForNonStdAdditions(cs, _T("DestinationDirs")) ;
|
|
m_csINFContents += cs ;
|
|
|
|
// Add the SourceDisksNames sections to the INF contents. Each section will
|
|
// include the Provider string.
|
|
|
|
cs.LoadString(IDS_INFText_SrcDiskNamesI) ;
|
|
ChkForNonStdAdditions(cs, _T("SourceDisksNames.x86")) ;
|
|
m_csINFContents += cs ;
|
|
|
|
// Add the SourceDisksFiles sections to the INF contents.
|
|
|
|
AddSourceDisksFilesSec(m_csINFContents) ;
|
|
|
|
// Add the nonstandard sections to the INF contents.
|
|
|
|
AddNonStandardSecs(m_csINFContents) ;
|
|
|
|
// Finish up by adding the Strings section to the INF contents.
|
|
|
|
cs.LoadString(IDS_INFText_Strings) ;
|
|
cs.Format(IDS_INFText_Strings, m_ciwmn.m_csMfgAbbrev, m_ciwmn.m_csMfgName,
|
|
m_ciwmn.m_csMfgName) ;
|
|
ChkForNonStdAdditions(cs, _T("Strings")) ;
|
|
m_csINFContents += cs ;
|
|
|
|
m_csaSrcDskFiles.RemoveAll() ; // Array not needed anymore
|
|
|
|
// All went well so...
|
|
|
|
return true ;
|
|
}
|
|
|
|
|
|
void CINFWizard::AddSourceDisksFilesSec(CString& csinf)
|
|
{
|
|
// Begin the section with the section header.
|
|
|
|
CString cs, cs2, csentry ;
|
|
cs.LoadString(IDS_INFTextSrcDiskFilesHdr) ;
|
|
|
|
// Remove any duplicate entries from source disk files array.
|
|
|
|
int n, n2 ;
|
|
for (n = 0 ; n < m_csaSrcDskFiles.GetSize() ; n++)
|
|
for (n2 = n + 1 ; n2 < m_csaSrcDskFiles.GetSize() ; )
|
|
if (m_csaSrcDskFiles[n] == m_csaSrcDskFiles[n2])
|
|
m_csaSrcDskFiles.RemoveAt(n2) ;
|
|
else
|
|
n2++ ;
|
|
|
|
// Get a count of the number of files in the source disk files array.
|
|
|
|
unsigned unumelts = (unsigned)m_csaSrcDskFiles.GetSize() ;
|
|
|
|
// Add an entry for each file in the array.
|
|
|
|
for (unsigned u = 0 ; u < unumelts ; u++) {
|
|
// Quote the file name if needed.
|
|
|
|
cs2 = m_csaSrcDskFiles[u] ;
|
|
//if (cs2[0] != _T('\"'))
|
|
// QuoteFile(cs2) ;
|
|
|
|
// Use the model's file name to build the entry for this model. Then
|
|
// add this entry to the section.
|
|
|
|
csentry.Format(IDS_INFText_SrcDiskFilesEntry, cs2) ;
|
|
cs += csentry ;
|
|
} ;
|
|
|
|
// Add any extra entries there might be for this section and then add the
|
|
// section to the INF contents.
|
|
|
|
ChkForNonStdAdditions(cs, _T("SourceDisksFiles")) ;
|
|
csinf += cs ;
|
|
}
|
|
|
|
|
|
void CINFWizard::ChkForNonStdAdditions(CString& cs, LPCTSTR strsection)
|
|
{
|
|
// Try to find the section amongst the list of sections with nonstandard
|
|
// additions.
|
|
|
|
CStringArray& csasections = m_ciwnse.m_csaSections ;
|
|
CString cssechdr ;
|
|
cssechdr = csLBrack + strsection + csRBrack ;
|
|
unsigned unumelts = (unsigned)csasections.GetSize() ;
|
|
for (unsigned u = 0 ; u < unumelts ; u++) {
|
|
if (csasections[u].CompareNoCase(cssechdr) == 0)
|
|
break ;
|
|
} ;
|
|
|
|
// If the section was found, mark the section as used and add the entries
|
|
// for the section to the string.
|
|
//
|
|
// DEAD_BUG - Sometimes, the user may have entered replacement entries for
|
|
// standard ones. This isn't handled correctly. :
|
|
// S.G : check the same keyword between cs and m_ciwnse exist, and replace cs keywod
|
|
// with that of m_ciwnse // raid 71332
|
|
unsigned unSize = 0 ;
|
|
if (u < unumelts ) {
|
|
CStringArray* pcsa ;
|
|
pcsa = (CStringArray*) m_ciwnse.m_coaSectionArrays[u] ;
|
|
|
|
unSize = (unsigned)pcsa->GetSize() ;
|
|
} ;
|
|
|
|
if ( unSize ) {
|
|
m_ciwnse.m_cuaSecUsed[u] = true ;
|
|
|
|
CStringArray* pcsa ;
|
|
pcsa = (CStringArray*) m_ciwnse.m_coaSectionArrays[u] ;
|
|
unumelts = (unsigned)pcsa->GetSize() ;
|
|
|
|
CUIntArray cuia ;
|
|
cuia.SetSize(10) ;
|
|
CStringArray csaNewcs;
|
|
int ulen = csCRLF.GetLength() ; // just in case, unicode : what is the length of "\r\n".
|
|
unsigned i , k ,utelen ;
|
|
i = k = utelen = 0 ;
|
|
while (-1 != (i = cs.Find(csCRLF, i + 1) ) ) {
|
|
utelen = i - k ;
|
|
csaNewcs.Add(cs.Mid(k,utelen + ulen) ); // we have to cut the string between csCR and csCR
|
|
k = i + ulen;
|
|
} ;
|
|
|
|
for (i = 0 ; i < unSize ; i++ )
|
|
cuia[i] = true;
|
|
|
|
for (i = 1; i < (unsigned)csaNewcs.GetSize() ; i++ ) {
|
|
CString cstmp = csaNewcs.GetAt(i);
|
|
cstmp = cstmp.Left(cstmp.Find(_T("=")) + 1) ;
|
|
if (! cstmp.CompareNoCase(_T("")) )
|
|
break;
|
|
for (u = 0 ; u < unSize ; u++) {
|
|
CString csKeyw = pcsa->GetAt(u) ;
|
|
CString csComp = csKeyw.Left(csKeyw.Find(_T("=")) + 1) ;
|
|
if(! cstmp.CompareNoCase (csComp) ) {
|
|
csKeyw += csCRLF ;
|
|
csaNewcs.SetAt(i,csKeyw) ;
|
|
cuia[u] = false;
|
|
} ;
|
|
|
|
} ;
|
|
} ;
|
|
for ( u = 0 ; u < unSize ; u ++ )
|
|
if (cuia[u] ) {
|
|
CString csAdd = pcsa->GetAt(u) ;
|
|
csAdd += csCRLF ;
|
|
csaNewcs.Add(csAdd) ;
|
|
} ;
|
|
CString csnew ;
|
|
for ( u = 0 ; u < (unsigned)csaNewcs.GetSize(); u ++ )
|
|
csnew += csaNewcs.GetAt(u);
|
|
|
|
cs = csnew ;
|
|
|
|
} ;
|
|
|
|
// Add an extra line to this section's strings to separate it from the
|
|
// next one.
|
|
|
|
|
|
cs += csCRLF ;
|
|
}
|
|
|
|
|
|
void CINFWizard::AddNonStandardSecs(CString& csinf)
|
|
{
|
|
CString cs ;
|
|
|
|
// Loop through each nonstandard section.
|
|
|
|
CStringArray& csasections = m_ciwnse.m_csaSections ;
|
|
unsigned unumelts = (unsigned)csasections.GetSize() ;
|
|
CStringArray* pcsa ;
|
|
unsigned u2, unumstrs ;
|
|
for (unsigned u = 0 ; u < unumelts ; u++) {
|
|
// Skip this section if it is not a nonstandard section. IE, its
|
|
// entries have already been added to one of the standard sections.
|
|
|
|
if (m_ciwnse.m_cuaSecUsed[u])
|
|
continue ;
|
|
|
|
// Skip this section if it is the Strings section. It will be added
|
|
// later.
|
|
|
|
if (csasections[u].CompareNoCase(_T("[Strings]")) == 0)
|
|
continue ;
|
|
|
|
// Get info about the section's entries. Skip the section if it has
|
|
// no entries.
|
|
|
|
pcsa = (CStringArray*) m_ciwnse.m_coaSectionArrays[u] ;
|
|
unumstrs = (unsigned)pcsa->GetSize() ;
|
|
if (unumstrs == 0)
|
|
continue ;
|
|
|
|
// Start the section with its header.
|
|
|
|
cs = csasections[u] + csCRLF ;
|
|
|
|
// Add each of the entries to the section.
|
|
|
|
for (u2 = 0 ; u2 < unumstrs ; u2++)
|
|
cs += pcsa->GetAt(u2) + csCRLF ;
|
|
cs += csCRLF ;
|
|
|
|
// Add the section to the INF contents
|
|
|
|
csinf += cs ;
|
|
} ;
|
|
}
|
|
|
|
|
|
void CINFWizard::BldModSpecSec(CString& csinf)
|
|
{
|
|
// Add the comment for this section to the INF file
|
|
|
|
CString cs, csl, csr, csfn, csmodel, cspnpid ;
|
|
cs.LoadString(IDS_INFText_ModCmt) ;
|
|
csinf += cs ;
|
|
|
|
// Build the section header
|
|
|
|
cs = csLBrack + m_ciwmn.m_csMfgName + csRBrack + csCRLF ;
|
|
|
|
// Build the entry for each model and add them to the section. The format
|
|
// is:
|
|
// "model name" = filename,PnP ID,model_name
|
|
|
|
CStringArray& csamodels = GetINFModels() ;
|
|
int nummodels = (int)csamodels.GetSize() ;
|
|
int n, npos, nlen ;
|
|
for (n = 0 ; n < nummodels ; n++) {
|
|
csmodel = csamodels[n] ;
|
|
csmodel.TrimLeft() ;
|
|
csmodel.TrimRight() ;
|
|
|
|
// If the user supplied a real PnP ID, it is used. If not, a pseudo
|
|
// PnP ID is generated.
|
|
|
|
if (!m_ciwgpi.m_csaModelIDs[n].IsEmpty())
|
|
cspnpid = m_ciwgpi.m_csaModelIDs[n] ;
|
|
else {
|
|
CCompatID ccid(m_ciwmn.m_csMfgName, csmodel) ;
|
|
ccid.GenerateID(cspnpid) ;
|
|
} ;
|
|
|
|
nlen = csmodel.GetLength() ;
|
|
while ((npos = csmodel.Find(_T(" "))) != -1) {
|
|
csl = (npos > 0) ? csmodel.Left(npos) : csEmpty ;
|
|
csr = (npos + 1 < nlen) ? csmodel.Right(nlen - npos - 1) : csEmpty ;
|
|
csmodel = csl + _T("_") + csr ;
|
|
} ;
|
|
csfn = GetModelFile(csamodels[n]) ;
|
|
//QuoteFile(csfn) ;
|
|
cs += csQuote + csamodels[n] + csQuote + csEq + csfn + csComma
|
|
+ cspnpid + csComma + csmodel + csCRLF ;
|
|
} ;
|
|
|
|
// Add non standard additions and then add the section to the INF file contents
|
|
|
|
ChkForNonStdAdditions(cs, m_ciwmn.m_csMfgName) ;
|
|
csinf += cs ;
|
|
}
|
|
|
|
|
|
void CINFWizard::BuildInstallAndCopySecs(CString& csinf)
|
|
{
|
|
// Add the comment for the Install sections to the INF contents
|
|
|
|
CString cs ;
|
|
cs.LoadString(IDS_INFText_InstallCmt) ;
|
|
csinf += cs ;
|
|
|
|
// Load the section components that will be needed repeatedly
|
|
|
|
CString cskey, csdrvdll ;
|
|
cskey.LoadString(IDS_INFText_CopyKey) ;
|
|
bool bbidiadded = false ; // True iff BiDi DLL in [SourceDiskFiles] array
|
|
|
|
// Create an install section for each model and add it the INF contents
|
|
|
|
CStringArray& csamodels = GetINFModels() ;
|
|
CStringArray csagpdfile ;
|
|
CString csmodelfile, cshdr, csinc(_T("*Include:")), cstmp ;
|
|
int numstrs, nloc ;
|
|
unsigned unummodels = (unsigned)csamodels.GetSize() ;
|
|
for (unsigned u = 0 ; u < unummodels ; u++) {
|
|
// Build the section header
|
|
|
|
cshdr = csmodelfile = GetModelFile(csamodels[u]) ;
|
|
cs = csLBrack + csmodelfile + csRBrack + csCRLF ;
|
|
|
|
// Read the GPD to get the DLL name & add it to SourceDiskFiles array.
|
|
|
|
if (!ReadGPDAndGetDLLName(csdrvdll,csamodels[u],csagpdfile,csmodelfile))
|
|
continue ;
|
|
|
|
// Build the copy files statement. Begin by adding the copy files
|
|
// entry, the DLL, and the GPD to the statement.
|
|
|
|
//QuoteFile(csmodelfile) ;
|
|
cs += cskey + csdrvdll + csComma + csAtSign + csmodelfile ;
|
|
m_csaSrcDskFiles.Add(csmodelfile) ; // Add to [SourceDiskFiles] array
|
|
|
|
// Add ICM files to the copy files entry when needed.
|
|
|
|
AddFileList(cs, (CStringArray*) m_ciwip.m_coaProfileArrays[u]) ;
|
|
|
|
// Add the nonstandard files for this model to the copy files entry
|
|
// when needed.
|
|
|
|
AddFileList(cs, (CStringArray*) m_ciwef.m_coaExtraFSArrays[u]) ;
|
|
|
|
// Scan the current model's GPD file for include statements.
|
|
// If any are found, add them to the copy files entry.
|
|
|
|
numstrs = (int) csagpdfile.GetSize() ;
|
|
for (int n = 0 ; n < numstrs ; n++) {
|
|
if ((nloc = csagpdfile[n].Find(csinc)) == -1)
|
|
continue ;
|
|
cstmp = csagpdfile[n].Mid(nloc + csinc.GetLength()) ;
|
|
cstmp.TrimLeft() ;
|
|
cstmp.TrimRight() ;
|
|
if (cstmp[0] == csQuote[0]) // Remove quotes
|
|
cstmp = cstmp.Mid(1, cstmp.GetLength() - 2) ;
|
|
if ((nloc = cstmp.ReverseFind(_T('\\'))) > -1) // Remove path
|
|
cstmp = cstmp.Right(cstmp.GetLength() - nloc - 1) ;
|
|
if (cstmp.CompareNoCase(_T("stdnames.gpd")) == 0)
|
|
continue ; // File include below
|
|
//QuoteFile(cstmp) ;
|
|
m_csaSrcDskFiles.Add(cstmp) ; // Add to [SourceDiskFiles] array
|
|
cs += csComma + csAtSign + cstmp ;
|
|
} ;
|
|
|
|
// Add any required nonstandard sections to the model's CopyFiles stmt.
|
|
|
|
AddNonStdSectionsForModel(cs, (int) u, csamodels[u]) ;
|
|
|
|
// Add the data sections statement to the Installs section
|
|
|
|
AddDataSectionStmt(cs, (int) u) ;
|
|
|
|
// Add the data file statement to the Install section
|
|
|
|
cstmp.Format(IDS_INFText_DataFileKey, csmodelfile) ;
|
|
cs += cstmp ;
|
|
|
|
// Add the Include and Needs statements to the Install section
|
|
|
|
AddIncludeNeedsStmts(cs, (int) u) ;
|
|
|
|
// Add the section to the INF contents.
|
|
|
|
//cs += csCRLF ;
|
|
ChkForNonStdAdditions(cs, cshdr) ;
|
|
csinf += cs ;
|
|
} ;
|
|
}
|
|
|
|
|
|
bool CINFWizard::ReadGPDAndGetDLLName(CString& csdrvdll, CString& csmodel,
|
|
CStringArray& csagpdfile,
|
|
CString& csmodelfile)
|
|
{
|
|
// Load the GPD file. Complain and return false if this fails.
|
|
|
|
CString cserr ;
|
|
|
|
if (!LoadFile(GetModelFile(csmodel, true), csagpdfile)) {
|
|
cserr.Format(IDS_INFGPDReadError, csmodelfile) ;
|
|
AfxMessageBox(cserr, MB_ICONEXCLAMATION) ;
|
|
return false ;
|
|
} ;
|
|
|
|
// Get the number of lines in the file and the DLL keyword.
|
|
|
|
int nloc ;
|
|
int numstrs = (int) csagpdfile.GetSize() ;
|
|
CString csdllkey(_T("*ResourceDLL:")) ;
|
|
|
|
// Look for the DLL name in the GPD file.
|
|
|
|
for (int n = 0 ; n < numstrs ; n++) {
|
|
// Continue if current line doesn't contain DLL file name.
|
|
|
|
if ((nloc = csagpdfile[n].Find(csdllkey)) == -1)
|
|
continue ;
|
|
|
|
// Isolate the DLL file name in the current statement.
|
|
|
|
csdrvdll = csagpdfile[n].Mid(nloc + csdllkey.GetLength()) ;
|
|
csdrvdll.TrimLeft() ;
|
|
csdrvdll.TrimRight() ;
|
|
if (csdrvdll[0] == csQuote[0]) // Remove quotes
|
|
csdrvdll = csdrvdll.Mid(1, csdrvdll.GetLength() - 2) ;
|
|
if ((nloc = csdrvdll.ReverseFind(_T('\\'))) > -1) // Remove path
|
|
csdrvdll = csdrvdll.Right(csdrvdll.GetLength() - nloc - 1) ;
|
|
|
|
// Add the DLL file name to the SourceDiskFiles array and then add an
|
|
// atsign to it so that it will be ready for future use.
|
|
|
|
m_csaSrcDskFiles.Add(csdrvdll) ;
|
|
csdrvdll = csAtSign + csdrvdll ;
|
|
return true ;
|
|
} ;
|
|
|
|
// If this point is reached, the DLL file name could not be found so
|
|
// complain and return false.
|
|
|
|
cserr.Format(IDS_INFNoDLLError, csmodelfile) ;
|
|
AfxMessageBox(cserr, MB_ICONEXCLAMATION) ;
|
|
return false ;
|
|
}
|
|
|
|
|
|
void CINFWizard::AddFileList(CString& cssection, CStringArray* pcsa)
|
|
{
|
|
int n, numstrs, npos ;
|
|
|
|
// If there is a list of files to add to the section...
|
|
|
|
if ((numstrs = (int)pcsa->GetSize()) > 0) {
|
|
// ... Add each file to the section
|
|
|
|
CString cstmp ;
|
|
for (n = 0 ; n < numstrs ; n++) {
|
|
cstmp = pcsa->GetAt(n) ;
|
|
|
|
// If the filespec contains a path, remove it.
|
|
|
|
if ((npos = cstmp.ReverseFind(_T('\\'))) > -1)
|
|
cstmp = cstmp.Right(cstmp.GetLength() - npos - 1) ;
|
|
|
|
// Quote the file name if it contains space(s).
|
|
|
|
//QuoteFile(cstmp) ;
|
|
|
|
m_csaSrcDskFiles.Add(cstmp) ; // Add to [SourceDiskFiles] array
|
|
|
|
// Add this file to the section.
|
|
|
|
cssection += csComma + csAtSign + cstmp ;
|
|
} ;
|
|
} ;
|
|
}
|
|
|
|
|
|
void CINFWizard::AddICMFilesToDestDirs(CString& cssection)
|
|
{
|
|
int n, n2, numstrs, npos, numarrays ;
|
|
CStringArray* pcsa ;
|
|
CString cstmp, cstmp2 ;
|
|
|
|
// Find out how many ICM file, string arrays there are.
|
|
|
|
numarrays = (int) m_ciwip.m_coaProfileArrays.GetSize() ;
|
|
|
|
// Check each array for ICM filespecs...
|
|
|
|
for (n = 0 ; n < numarrays ; n++) {
|
|
// Find out how many strings are in the current array
|
|
|
|
pcsa = (CStringArray*) m_ciwip.m_coaProfileArrays[n] ;
|
|
numstrs = (int) pcsa->GetSize() ;
|
|
|
|
// Add each string in the current array to the DestinationDirs section.
|
|
|
|
for (n2 = 0 ; n2 < numstrs ; n2++) {
|
|
cstmp = pcsa->GetAt(n2) ;
|
|
|
|
// If the filespec contains a path, remove it.
|
|
|
|
if ((npos = cstmp.ReverseFind(_T('\\'))) > -1)
|
|
cstmp = cstmp.Right(cstmp.GetLength() - npos - 1) ;
|
|
|
|
// Format the statement for this file and add it to the section.
|
|
|
|
cstmp2.Format(IDS_INFText_ICMDest,cstmp) ;
|
|
cssection += cstmp2 ;
|
|
} ;
|
|
} ;
|
|
}
|
|
|
|
|
|
CString CINFWizard::GetModelFile(CString& csmodel, bool bfspec/*=false*/)
|
|
{
|
|
// Find the class instance associated with the specified model.
|
|
|
|
//RAID 0001
|
|
if(m_pcgc){
|
|
CString csFileName = m_pcgc->ModelData()->GetKeywordValue(m_pcgc->
|
|
GetPathName(),_T("GPDFileName"));
|
|
|
|
if (bfspec)
|
|
return m_pcgc->GetPathName() ;
|
|
else
|
|
return csFileName;
|
|
}
|
|
|
|
else
|
|
{
|
|
//END 0001
|
|
unsigned unummodels = GetModelCount() ;
|
|
for (unsigned u = 0 ; u < unummodels ; u++) {
|
|
if (csmodel == GetModel(u).Name())
|
|
break ;
|
|
} ;
|
|
ASSERT(u < unummodels) ;
|
|
|
|
// Either return a full filespec or just a file name.
|
|
|
|
if (bfspec)
|
|
return (GetModel(u).FileName()) ;
|
|
else
|
|
return (GetModel(u).FileTitleExt()) ;
|
|
} // else{ END RAID 0001
|
|
}
|
|
|
|
|
|
void CINFWizard::AddDataSectionStmt(CString& csinst, int nmod)
|
|
{
|
|
// Prepare to determine the contents of the data section statement.
|
|
|
|
CString cs, cs2 ;
|
|
cs2 = csEmpty ;
|
|
int nid = IDS_DataSecUni ;
|
|
CUIntArray* pcuia = (CUIntArray*) m_ciwds.m_coaStdDataSecs[nmod] ;
|
|
|
|
// Find the only one - if any - of the first three data section names that
|
|
// can be added to the statement.
|
|
|
|
for (int n = 0 ; n < NUMDATASECFLAGS - 1 ; n++, nid++)
|
|
if ((*pcuia)[n]) {
|
|
cs2.LoadString(nid) ;
|
|
break ;
|
|
} ;
|
|
|
|
// If there is a nonstandard data section, add it too.
|
|
|
|
if ((*pcuia)[IDF_OTHER]) {
|
|
if (!cs2.IsEmpty())
|
|
cs2 += csComma ;
|
|
cs2 += m_ciwds.m_csaOtherDataSecs[nmod] ;
|
|
} ;
|
|
|
|
// Finish formating the data section statement and add it to the rest of
|
|
// the install section.
|
|
|
|
cs.Format(IDS_INFText_DataSecKey, cs2) ;
|
|
csinst += cs ;
|
|
}
|
|
|
|
|
|
void CINFWizard::AddIncludeNeedsStmts(CString& csinst, int nmod)
|
|
{
|
|
CString cs, cs2 ;
|
|
|
|
// Build the Include statement and add it to the section..
|
|
|
|
cs.Format(IDS_INFText_IncludeKey, m_ciwif.m_csaIncFiles[nmod]) ;
|
|
csinst += cs ;
|
|
|
|
// Prepare to determine the contents of the needs section statement.
|
|
|
|
cs2 = csEmpty ;
|
|
CUIntArray* pcuia = (CUIntArray*) m_ciwis.m_coaStdInstSecs[nmod] ;
|
|
|
|
// The TrueType section, if needed, is the first section to list in the
|
|
// Includes statement.
|
|
|
|
if ((*pcuia)[ISF_TTF])
|
|
cs2.LoadString(IDS_InstSecTtf) ;
|
|
|
|
// Find the only one - if any - of the first three install section names
|
|
// that can be added to the statement.
|
|
|
|
int nid = IDS_InstSecUni ;
|
|
for (int n = 0 ; n < NUMINSTSECFLAGS - 2 ; n++, nid++)
|
|
if ((*pcuia)[n]) {
|
|
if (!cs2.IsEmpty())
|
|
cs2 += csComma ;
|
|
cs.LoadString(nid) ;
|
|
cs2 += cs ;
|
|
break ;
|
|
} ;
|
|
|
|
// If there is a nonstandard install section, add it too.
|
|
|
|
if ((*pcuia)[ISF_OTHER]) {
|
|
if (!cs2.IsEmpty())
|
|
cs2 += csComma ;
|
|
cs2 += m_ciwis.m_csaOtherInstSecs[nmod] ;
|
|
} ;
|
|
|
|
// Finish formating the install section statement and add it to the rest of
|
|
// the install section.
|
|
|
|
cs.Format(IDS_INFText_NeedsKey, cs2) ;
|
|
csinst += cs ;
|
|
}
|
|
|
|
|
|
void CINFWizard::AddNonStdSectionsForModel(CString& csinst, int nmod,
|
|
CString& csmodel)
|
|
{
|
|
// Declare looping variables and find out how many nonstd sections there are
|
|
|
|
int n, n2, n3 ;
|
|
int numelts = (int) m_ciwnsms.m_csaSections.GetSize() ;
|
|
|
|
// If this is the first time this function is called, size and initialize
|
|
// the "this section has already been added to the SourceDiskFiles" flags.
|
|
|
|
if (nmod == 0) {
|
|
m_cuiaNonStdSecsFlags.SetSize(numelts) ;
|
|
for (n = 0 ; n < numelts ; n++)
|
|
m_cuiaNonStdSecsFlags[n] = 0 ;
|
|
} ;
|
|
|
|
// Loop through all of the nonstandard sections looking for one that
|
|
// references the current model.
|
|
|
|
CStringArray* pcsa ;
|
|
CStringArray* pcsa2 ;
|
|
CString cssec ;
|
|
for (n = 0 ; n < numelts ; n++) {
|
|
// Get a pointer to the names of models that need the current section.
|
|
|
|
pcsa = (CStringArray*) m_ciwnsms.m_coaModelsNeedingSecs[n] ;
|
|
|
|
// Check each model in the above list to see if it matches the model
|
|
// passed in as an argument to this function.
|
|
|
|
for (n2 = 0 ; n2 < pcsa->GetSize() ; n2++)
|
|
// If a match is found...
|
|
|
|
if ((*pcsa)[n2] == csmodel) {
|
|
// ...add the section name to the model's CopyFiles statement
|
|
// (Strip the brackets off first.)...
|
|
|
|
cssec = m_ciwnsms.m_csaSections[n] ;
|
|
cssec = cssec.Mid(1, cssec.GetLength() - 2) ;
|
|
csinst += csComma + cssec ;
|
|
|
|
// ...and make sure that the sections files are listed in the
|
|
// SourceDiskFiles section.
|
|
|
|
if (!m_cuiaNonStdSecsFlags[n]) {
|
|
pcsa2 = (CStringArray*) m_ciwnse.m_coaSectionArrays[n] ;
|
|
for (n3 = 0 ; n3 < pcsa2->GetSize() ; n3++)
|
|
m_csaSrcDskFiles.Add((*pcsa2)[n3]) ; // Add to [SourceDiskFiles] array
|
|
m_cuiaNonStdSecsFlags[n] = 1 ;
|
|
} ;
|
|
break ;
|
|
} ;
|
|
} ;
|
|
}
|
|
|
|
|
|
void CINFWizard::PrepareToRestart()
|
|
{
|
|
// Set the flags needed to get the pages to reinitialize themselves but
|
|
// keep all existing data.
|
|
|
|
m_ciwm.m_bReInitWData = m_ciwbd.m_bReInitWData = true ;
|
|
m_ciwip.m_bReInitWData = m_ciwef.m_bReInitWData = true ;
|
|
m_ciwmn.m_bReInitWData = m_ciwnse.m_bReInitWData = true ;
|
|
m_ciws.m_bReInitWData = m_ciwif.m_bReInitWData = true ;
|
|
m_ciwis.m_bReInitWData = m_ciwds.m_bReInitWData = true ;
|
|
m_ciwnsms.m_bReInitWData = m_ciwgpi.m_bReInitWData = true ;
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFWizard, CPropertySheet)
|
|
//{{AFX_MSG_MAP(CINFWizard)
|
|
// NOTE - the ClassWizard will add and remove mapping macros here.
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizard message handlers
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizWelcome property page
|
|
|
|
IMPLEMENT_DYNCREATE(CINFWizWelcome, CPropertyPage)
|
|
|
|
CINFWizWelcome::CINFWizWelcome() : CPropertyPage(CINFWizWelcome::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CINFWizWelcome)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bInitialized = false ;
|
|
}
|
|
|
|
CINFWizWelcome::~CINFWizWelcome()
|
|
{
|
|
}
|
|
|
|
void CINFWizWelcome::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPage::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CINFWizWelcome)
|
|
// NOTE: the ClassWizard will add DDX and DDV calls here
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFWizWelcome, CPropertyPage)
|
|
//{{AFX_MSG_MAP(CINFWizWelcome)
|
|
// NOTE: the ClassWizard will add message map macros here
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizWelcome message handlers
|
|
|
|
BOOL CINFWizWelcome::OnSetActive()
|
|
{
|
|
// We wish to disable the "Back" button here.
|
|
|
|
m_pciwParent->SetWizardButtons(PSWIZB_NEXT) ;
|
|
m_pciwParent->GetDlgItem(IDHELP)->ShowWindow(SW_HIDE) ;
|
|
|
|
m_bInitialized = true ; // Page is initialized now
|
|
|
|
return CPropertyPage::OnSetActive();
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizModels property page
|
|
|
|
IMPLEMENT_DYNCREATE(CINFWizModels, CPropertyPage)
|
|
|
|
CINFWizModels::CINFWizModels() : CPropertyPage(CINFWizModels::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CINFWizModels)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
// Initialize member variables
|
|
|
|
m_bInitialized = m_bSelChanged = m_bReInitWData = false ;
|
|
m_uNumModels = m_uNumModelsSel = 0 ;
|
|
}
|
|
|
|
CINFWizModels::~CINFWizModels()
|
|
{
|
|
}
|
|
|
|
void CINFWizModels::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPage::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CINFWizModels)
|
|
DDX_Control(pDX, IDC_ModelsList, m_cfelcModels);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFWizModels, CPropertyPage)
|
|
//{{AFX_MSG_MAP(CINFWizModels)
|
|
// NOTE: the ClassWizard will add message map macros here
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizModels message handlers
|
|
|
|
BOOL CINFWizModels::OnSetActive()
|
|
{
|
|
// Reenable the "Back" button.
|
|
CString cstmp ; // RAID 0001 move to head from body
|
|
m_pciwParent->SetWizardButtons(PSWIZB_NEXT | PSWIZB_BACK) ;
|
|
|
|
m_cfelcModels.SetFocus() ; // The list control gets the focus
|
|
|
|
// If this page has been initialized already, make a copy of the current
|
|
// selections and set the flag that indicates that the selection may be
|
|
// changing. See below for more info.
|
|
// RAID 0001
|
|
if(NULL != m_pciwParent->m_pcgc ){
|
|
CString csFilePath = m_pciwParent->m_pcgc->GetPathName();
|
|
CString csModelName = m_pciwParent->m_pcgc->ModelData()->
|
|
GetKeywordValue(csFilePath,_T("ModelName"));
|
|
|
|
m_uNumModels = 1;
|
|
m_csaModels.RemoveAll( );
|
|
m_csaModels.Add(csModelName);
|
|
|
|
if (m_bInitialized && !m_bReInitWData)
|
|
return CPropertyPage::OnSetActive() ;
|
|
|
|
m_csToggleStr.LoadString(IDS_INFModelsToggleStr) ;
|
|
m_csaInclude.RemoveAll();
|
|
m_csaInclude.Add(m_csToggleStr);
|
|
|
|
}
|
|
|
|
else {
|
|
//END RAID 0001
|
|
|
|
unsigned u ;
|
|
if (m_bInitialized) {
|
|
m_csaModelsLast.SetSize(m_uNumModelsSel) ;
|
|
for (u = 0 ; u < m_uNumModelsSel ; u++)
|
|
m_csaModelsLast[u] = m_csaModels[u] ;
|
|
m_bSelChanged = true ;
|
|
|
|
// Nothing more need be done if the page is not being reinitialized.
|
|
|
|
if (!m_bReInitWData)
|
|
return CPropertyPage::OnSetActive() ;
|
|
} ;
|
|
|
|
// The following info is needed when reinitializing and is used/described
|
|
// later.
|
|
|
|
unsigned unumselected, u2, ureinitidx ;
|
|
if (m_bReInitWData)
|
|
unumselected = ureinitidx = (unsigned)m_csaModels.GetSize() ;
|
|
|
|
// Save the number of models in the project and use this number to set the
|
|
// length of the models string array.
|
|
|
|
m_uNumModels = m_pciwParent->GetModelCount() ;
|
|
m_csaModels.SetSize(m_uNumModels) ;
|
|
if (!m_bReInitWData)
|
|
m_csaInclude.RemoveAll() ;
|
|
|
|
// Load the model names into the models string array. This is straight
|
|
// forward if we are NOT reinitializing but more complicated when we are
|
|
// reinitializing. In the latter case, the user's previous selections
|
|
// must be maintained at the beginning of the array. The rest of the
|
|
// models should be added to array after the selections.
|
|
|
|
// CString cstmp ; RAID 0001
|
|
for (u = 0 ; u < m_uNumModels ; u++) {
|
|
cstmp = m_pciwParent->GetModel(u).Name() ;
|
|
|
|
// If not reinitializing, just add the model name to the array.
|
|
|
|
if (!m_bReInitWData)
|
|
m_csaModels[u] = cstmp ;
|
|
|
|
// Otherwise only add the model name to the array if it is not one of
|
|
// the selected models that are already in the array.
|
|
|
|
else {
|
|
for (u2 = 0 ; u2 < unumselected ; u2++)
|
|
if (m_csaModels[u2] == cstmp)
|
|
break ;
|
|
if (u2 >= unumselected)
|
|
m_csaModels[ureinitidx++] = cstmp ;
|
|
} ;
|
|
} ;
|
|
|
|
// Initialize the list control
|
|
} // RAID 0001. else {
|
|
m_cfelcModels.InitControl(LVS_EX_FULLROWSELECT, m_uNumModels, 2,
|
|
TF_HASTOGGLECOLUMNS+TF_CLICKONROW, 0,
|
|
MF_IGNOREINSDEL) ;
|
|
|
|
// Load the models column in the list control.
|
|
|
|
cstmp.LoadString(IDS_INFModelsColLab) ;
|
|
m_cfelcModels.InitLoadColumn(0, cstmp, COMPUTECOLWIDTH, 20, false, true,
|
|
COLDATTYPE_STRING, (CObArray*) &m_csaModels) ;
|
|
|
|
// Initialize the includes column in the list control.
|
|
|
|
cstmp.LoadString(IDS_INFIncludesColLab) ;
|
|
m_csToggleStr.LoadString(IDS_INFModelsToggleStr) ;
|
|
m_cfelcModels.InitLoadColumn(1, cstmp, SETWIDTHTOREMAINDER, -20, false,
|
|
true, COLDATTYPE_TOGGLE,
|
|
(CObArray*) &m_csaInclude, m_csToggleStr) ;
|
|
|
|
m_bInitialized = true ; // Page is initialized now
|
|
m_bReInitWData = false ; // Reinit is done now on this page
|
|
return CPropertyPage::OnSetActive() ;
|
|
}
|
|
|
|
|
|
LRESULT CINFWizModels::OnWizardNext()
|
|
{
|
|
// Make sure the list's contents are sorted in descending order by included
|
|
// status.
|
|
|
|
m_cfelcModels.SortControl(1) ;
|
|
if (m_cfelcModels.GetColSortOrder(1))
|
|
m_cfelcModels.SortControl(1) ;
|
|
|
|
// Get the data in the included status column.
|
|
|
|
m_cfelcModels.GetColumnData((CObArray*) &m_csaInclude, 1) ;
|
|
|
|
// Complain and don't let the user continue if no models were selected.
|
|
|
|
if (m_csaInclude.GetSize() == 0 || m_csaInclude[0].IsEmpty()) {
|
|
CString csmsg ;
|
|
csmsg.LoadString(IDS_INFNoModelsSel) ;
|
|
AfxMessageBox(csmsg, MB_ICONEXCLAMATION) ;
|
|
return -1 ;
|
|
} ;
|
|
|
|
// Get the data in the models column.
|
|
|
|
m_cfelcModels.GetColumnData((CObArray*) &m_csaModels, 0) ;
|
|
|
|
// Determine the number of included models and use this count to resize the
|
|
// models array.
|
|
|
|
m_uNumModelsSel = 0 ;
|
|
for (unsigned u = 0 ; u < m_uNumModels ; u++) {
|
|
if (m_csaInclude[u].IsEmpty())
|
|
break ;
|
|
m_uNumModelsSel++ ;
|
|
} ;
|
|
m_csaModels.SetSize(m_uNumModelsSel) ;
|
|
|
|
// Call the sheet class to set the the other pages' fixup flags if the
|
|
// selection changed.
|
|
|
|
if (m_bSelChanged) {
|
|
m_pciwParent->SetFixupFlags() ;
|
|
m_bSelChanged = false ;
|
|
} ;
|
|
|
|
// All went well so move on to the next wizard page.
|
|
|
|
return CPropertyPage::OnWizardNext() ;
|
|
}
|
|
|
|
|
|
int IdentifyOldAndNewModels(CStringArray& csanewmodels, CUIntArray& cuiaoldmodelsfound,
|
|
CUIntArray& cuianewmodelsfound, int& newnumelts,
|
|
CStringArray& csamodels)
|
|
{
|
|
int n, n2 ; // Looping variables
|
|
|
|
// Get the number of models in the new and old lists.
|
|
|
|
int numelts = (int) csamodels.GetSize() ;
|
|
newnumelts = (int) csanewmodels.GetSize() ;
|
|
|
|
// Declare and initialize flag arrays used to determine which models are
|
|
// in use.
|
|
|
|
cuiaoldmodelsfound.SetSize(numelts) ;
|
|
for (n = 0 ; n < numelts ; n++)
|
|
cuiaoldmodelsfound[n] = 0 ;
|
|
cuianewmodelsfound.SetSize(newnumelts) ;
|
|
for (n = 0 ; n < newnumelts ; n++)
|
|
cuianewmodelsfound[n] = 0 ;
|
|
|
|
// Loop through the old & new models to see which of them are still in use.
|
|
|
|
for (n = 0 ; n < numelts ; n++)
|
|
for (n2 = 0 ; n2 < newnumelts ; n2++)
|
|
if (csamodels[n] == csanewmodels[n2]) {
|
|
cuiaoldmodelsfound[n] = cuianewmodelsfound[n2] = 1 ;
|
|
break ;
|
|
} ;
|
|
|
|
// Return the number models previously selected
|
|
|
|
return numelts ;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizGetPnPIDs property page
|
|
|
|
IMPLEMENT_DYNCREATE(CINFWizGetPnPIDs, CPropertyPage)
|
|
|
|
CINFWizGetPnPIDs::CINFWizGetPnPIDs() : CPropertyPage(CINFWizGetPnPIDs::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CINFWizGetPnPIDs)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bInitialized = m_bReInitWData = m_bSelChanged = false ;
|
|
}
|
|
|
|
CINFWizGetPnPIDs::~CINFWizGetPnPIDs()
|
|
{
|
|
}
|
|
|
|
|
|
void CINFWizGetPnPIDs::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPage::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CINFWizGetPnPIDs)
|
|
DDX_Control(pDX, IDC_ModelsPnPIDList, m_felcModelIDs);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFWizGetPnPIDs, CPropertyPage)
|
|
//{{AFX_MSG_MAP(CINFWizGetPnPIDs)
|
|
// NOTE: the ClassWizard will add message map macros here
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizGetPnPIDs message handlers
|
|
|
|
BOOL CINFWizGetPnPIDs::OnSetActive()
|
|
{
|
|
// Just perform the default actions if nothing special needs to be done.
|
|
|
|
if (m_bInitialized && (!m_bReInitWData) && (!m_bSelChanged))
|
|
return CPropertyPage::OnSetActive() ;
|
|
|
|
int n, n2 ; // Looping and indexing variables
|
|
|
|
// Perform the first time initialization.
|
|
|
|
if (!m_bInitialized) {
|
|
// Get a copy of the selected model names. Then make the PnP ID array
|
|
// the same size and initialize each entry to empty.
|
|
|
|
m_csaModels.Copy(m_pciwParent->GetINFModels()) ;
|
|
m_csaModelIDs.SetSize(m_csaModels.GetSize()) ;
|
|
for (n = 0 ; n < m_csaModelIDs.GetSize() ; n++)
|
|
m_csaModelIDs[n] = csEmpty ;
|
|
|
|
// Initialize and load the list control
|
|
|
|
InitModelsIDListCtl() ;
|
|
|
|
// Set init flag, reset other flags, and return whatever the base class
|
|
// function returns.
|
|
|
|
m_bInitialized = true ;
|
|
m_bReInitWData = m_bSelChanged = false ;
|
|
return CPropertyPage::OnSetActive() ;
|
|
} ;
|
|
|
|
// Either the selected models have changed or the wizard is being
|
|
// reinitialized if this point is reached. They are handled in similar
|
|
// ways.
|
|
//
|
|
// Begin by getting info about the models in this page and the ones that
|
|
// are selected now.
|
|
|
|
CStringArray& csanewmodels = m_pciwParent->GetINFModels() ;
|
|
CUIntArray cuiaoldmodelsfound, cuianewmodelsfound ;
|
|
int numelts, newnumelts ;
|
|
numelts = IdentifyOldAndNewModels(csanewmodels, cuiaoldmodelsfound,
|
|
cuianewmodelsfound, newnumelts,
|
|
m_csaModels) ;
|
|
|
|
// Remove the old models and related data that are no longer needed.
|
|
|
|
for (n = numelts - 1 ; n >= 0 ; n--)
|
|
if (cuiaoldmodelsfound[n] == 0) {
|
|
m_csaModels.RemoveAt(n) ;
|
|
m_csaModelIDs.RemoveAt(n) ;
|
|
} ;
|
|
|
|
// Add the truly new models to this page's array of model names and
|
|
// initialize all related data for it.
|
|
|
|
for (n = n2 = 0 ; n < newnumelts ; n++) {
|
|
if (cuianewmodelsfound[n] == 1) {
|
|
n2++ ;
|
|
continue ;
|
|
} ;
|
|
m_csaModels.InsertAt(n2, csanewmodels[n]) ;
|
|
m_csaModelIDs.InsertAt(n2, csEmpty) ;
|
|
} ;
|
|
|
|
// Reinitialize the list control if the wizard has been reinitialized.
|
|
// Otherwise, just reload the columns in the list control.
|
|
|
|
if (m_bReInitWData)
|
|
InitModelsIDListCtl() ;
|
|
else {
|
|
// If necessary, zap extra old data that could be left in the control
|
|
// after the new data is loaded.
|
|
|
|
if (numelts > newnumelts) {
|
|
CStringArray csa ;
|
|
csa.SetSize(numelts) ;
|
|
for (n = 0 ; n < numelts ; n++)
|
|
csa[n] = csEmpty ;
|
|
m_felcModelIDs.SetColumnData((CObArray*) &csa, 0) ;
|
|
m_felcModelIDs.SetColumnData((CObArray*) &csa, 1) ;
|
|
} ;
|
|
|
|
m_felcModelIDs.SetColumnData((CObArray*) &m_csaModels, 0) ;
|
|
m_felcModelIDs.SetColumnData((CObArray*) &m_csaModelIDs, 1) ;
|
|
} ;
|
|
|
|
// Set init flag, reset other flags, and return whatever the base class
|
|
// function returns.
|
|
|
|
m_bInitialized = true ;
|
|
m_bReInitWData = m_bSelChanged = false ;
|
|
return CPropertyPage::OnSetActive() ;
|
|
}
|
|
|
|
|
|
LRESULT CINFWizGetPnPIDs::OnWizardNext()
|
|
{
|
|
// Get the data in the PnP ID column.
|
|
|
|
m_felcModelIDs.GetColumnData((CObArray*) &m_csaModelIDs, 1) ;
|
|
|
|
// Complain and exit without allowing the wizard page to change if a PnP ID
|
|
// is found that contains spaces.
|
|
|
|
int numelts = (int) m_csaModelIDs.GetSize() ;
|
|
for (int n = 0 ; n < numelts ; n++) {
|
|
if (m_csaModelIDs[n].Find(_T(' ')) >= 0) {
|
|
AfxMessageBox(IDS_PnPSpacesError, MB_ICONEXCLAMATION) ;
|
|
return -1 ;
|
|
} ;
|
|
} ;
|
|
|
|
return CPropertyPage::OnWizardNext();
|
|
}
|
|
|
|
|
|
LRESULT CINFWizGetPnPIDs::OnWizardBack()
|
|
{
|
|
// This works because the same thing needs to be done for both
|
|
// OnWizardNext() and OnWizardBack(). In addition,
|
|
// CPropertyPage::OnWizardNext() and CPropertyPage::OnWizardBack() just
|
|
// return 0.
|
|
|
|
return OnWizardNext() ;
|
|
}
|
|
|
|
|
|
void CINFWizGetPnPIDs::InitModelsIDListCtl()
|
|
{
|
|
int numelts ; // Number of elements in an array
|
|
CString cstmp ;
|
|
|
|
// Initialize the list control
|
|
|
|
numelts = (int) m_csaModels.GetSize() ;
|
|
m_felcModelIDs.InitControl(LVS_EX_FULLROWSELECT, numelts, 2, 0, 0,
|
|
MF_IGNOREINSDEL) ;
|
|
|
|
// Load the models column in the list control.
|
|
|
|
cstmp.LoadString(IDS_INFModelsColLab) ;
|
|
m_felcModelIDs.InitLoadColumn(0, cstmp, COMPUTECOLWIDTH, 25, false,
|
|
false, COLDATTYPE_STRING,
|
|
(CObArray*) &m_csaModels) ;
|
|
|
|
// Initialize the PnP ID column in the list control.
|
|
|
|
cstmp.LoadString(IDS_INFPnPIDColLab) ;
|
|
m_felcModelIDs.InitLoadColumn(1, cstmp, SETWIDTHTOREMAINDER, -25,
|
|
true, false, COLDATTYPE_STRING,
|
|
(CObArray*) &m_csaModelIDs) ;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizBiDi property page
|
|
|
|
IMPLEMENT_DYNCREATE(CINFWizBiDi, CPropertyPage)
|
|
|
|
CINFWizBiDi::CINFWizBiDi() : CPropertyPage(CINFWizBiDi::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CINFWizBiDi)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bInitialized = m_bReInitWData = m_bSelChanged = false ;
|
|
}
|
|
|
|
|
|
CINFWizBiDi::~CINFWizBiDi()
|
|
{
|
|
}
|
|
|
|
|
|
void CINFWizBiDi::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPage::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CINFWizBiDi)
|
|
DDX_Control(pDX, IDC_ModelsList, m_cfelcBiDi);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
void CINFWizBiDi::ModelChangeFixups(unsigned unummodelssel,
|
|
CStringArray& csamodels,
|
|
CStringArray& csamodelslast)
|
|
{
|
|
// Declare looping vars, get the size of the old selection array, and
|
|
// declare and size a new flags array.
|
|
|
|
unsigned u, u2, unumlst ;
|
|
unumlst = (unsigned)csamodelslast.GetSize() ;
|
|
CUIntArray cuaflags ;
|
|
cuaflags.SetSize(unummodelssel) ;
|
|
|
|
// Try to find each new model in the list of old models. If found, copy the
|
|
// models flag. If not found, initialize the models flag to false.
|
|
|
|
for (u = 0 ; u < unummodelssel ; u++) {
|
|
for (u2 = 0 ; u2 < unumlst ; u2++) {
|
|
if (csamodels[u] == csamodelslast[u2])
|
|
break ;
|
|
} ;
|
|
cuaflags[u] = (u2 < unumlst) ? m_cuaBiDiFlags[u2] : false ;
|
|
} ;
|
|
|
|
// Copy the new flags array back into the member variable flags array.
|
|
|
|
m_cuaBiDiFlags.SetSize(unummodelssel) ;
|
|
for (u = 0 ; u < unummodelssel ; u++)
|
|
m_cuaBiDiFlags[u] = cuaflags[u] ;
|
|
|
|
// Now that the data structures are up to date, load the list control with
|
|
// the new information. (This part only needed if NOT reinitializing.)
|
|
|
|
if (!m_bReInitWData) {
|
|
m_cfelcBiDi.SetColumnData((CObArray*) &csamodels, 0) ;
|
|
CString cs ;
|
|
for (u = 0 ; u < unummodelssel ; u++) {
|
|
cs = (m_cuaBiDiFlags[u]) ? m_csToggleStr : csEmpty ;
|
|
VERIFY(m_cfelcBiDi.SetItemText(u, 1, cs)) ;
|
|
} ;
|
|
} ;
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFWizBiDi, CPropertyPage)
|
|
//{{AFX_MSG_MAP(CINFWizBiDi)
|
|
// NOTE: the ClassWizard will add message map macros here
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizBiDi message handlers
|
|
|
|
BOOL CINFWizBiDi::OnSetActive()
|
|
{
|
|
m_cfelcBiDi.SetFocus() ; // The list control gets the focus
|
|
|
|
// Nothing else need be done if this page has been initialized already
|
|
// and it is not being asked to reinitialize the page... That is,
|
|
// except for possibly needing to pick up any selected model changes
|
|
// that were made.
|
|
|
|
if (m_bInitialized && !m_bReInitWData) {
|
|
if (m_bSelChanged) {
|
|
ModelChangeFixups(m_pciwParent->GetINFModsSelCount(),
|
|
m_pciwParent->GetINFModels(),
|
|
m_pciwParent->GetINFModelsLst()) ;
|
|
m_bSelChanged = false ;
|
|
} ;
|
|
return CPropertyPage::OnSetActive() ;
|
|
} ;
|
|
|
|
// Get the array of selected models and declare an array for BiDi info.
|
|
|
|
CStringArray& csamodels = m_pciwParent->GetINFModels() ;
|
|
CStringArray csabidi ;
|
|
unsigned unumelts = (unsigned)csamodels.GetSize() ;
|
|
m_csToggleStr.LoadString(IDS_INFBiDiToggleStr) ;
|
|
|
|
// If not reinitializing, make sure the BiDi array is empty. Otherwise,
|
|
// initialize the BiDi strings array based on the settings in the BiDi
|
|
// flags array.
|
|
|
|
if (!m_bReInitWData)
|
|
csabidi.RemoveAll() ;
|
|
else {
|
|
ModelChangeFixups(m_pciwParent->GetINFModsSelCount(),
|
|
m_pciwParent->GetINFModels(),
|
|
m_pciwParent->GetINFModelsLst()) ;
|
|
csabidi.SetSize(unumelts) ;
|
|
for (unsigned u = 0 ; u < unumelts ; u++)
|
|
if (m_cuaBiDiFlags[u])
|
|
csabidi[u] = m_csToggleStr ;
|
|
} ;
|
|
|
|
// Initialize the list control
|
|
|
|
m_cfelcBiDi.InitControl(LVS_EX_FULLROWSELECT, unumelts, 2,
|
|
TF_HASTOGGLECOLUMNS+TF_CLICKONROW, 0,
|
|
MF_IGNOREINSDEL) ;
|
|
|
|
// Load the models column in the list control.
|
|
|
|
CString cstmp ;
|
|
cstmp.LoadString(IDS_INFModelsColLab) ;
|
|
m_cfelcBiDi.InitLoadColumn(0, cstmp, COMPUTECOLWIDTH, 40, false, true,
|
|
COLDATTYPE_STRING, (CObArray*) &csamodels) ;
|
|
|
|
// Initialize the bidi column in the list control.
|
|
|
|
cstmp.LoadString(IDS_INFBiDiColLab) ;
|
|
m_cfelcBiDi.InitLoadColumn(1, cstmp, SETWIDTHTOREMAINDER, -20, false, true,
|
|
COLDATTYPE_TOGGLE, (CObArray*) &csabidi,
|
|
m_csToggleStr) ;
|
|
|
|
m_bInitialized = true ; // Page is initialized now
|
|
m_bReInitWData = false ; // Reinit (if needed) is done now on this page
|
|
return CPropertyPage::OnSetActive() ;
|
|
}
|
|
|
|
|
|
LRESULT CINFWizBiDi::OnWizardNext()
|
|
{
|
|
// Make sure the list's contents are sorted in descending order by BI-DI
|
|
// status.
|
|
|
|
m_cfelcBiDi.SortControl(1) ;
|
|
if (m_cfelcBiDi.GetColSortOrder(1))
|
|
m_cfelcBiDi.SortControl(1) ;
|
|
|
|
// Get the data in the models and BI-DI status columns. Then get the
|
|
// original list of selected models.
|
|
|
|
CStringArray csamodels, csabidi ;
|
|
m_cfelcBiDi.GetColumnData((CObArray*) &csamodels, 0) ;
|
|
m_cfelcBiDi.GetColumnData((CObArray*) &csabidi, 1) ;
|
|
CStringArray& csaselmodels = m_pciwParent->GetINFModels() ;
|
|
|
|
// Get the length of the arrays and use it to size the array that is used
|
|
// to hold the BI-DI flags.
|
|
|
|
unsigned unummodels = (unsigned)csaselmodels.GetSize() ;
|
|
m_cuaBiDiFlags.SetSize(unummodels) ;
|
|
|
|
// Now we need to set the BIDI flags correctly. This is complicated a bit
|
|
// because the models array from the Bi-Di list may not be in the same
|
|
// order as the selected models array. The flags array should map to the
|
|
// selected models array. There is extra code below to deal with this.
|
|
|
|
for (unsigned u = 0 ; u < unummodels ; u++) {
|
|
for (unsigned u2 = 0 ; u2 < unummodels ; u2++) {
|
|
if (csaselmodels[u] == csamodels[u2]) {
|
|
m_cuaBiDiFlags[u] = !csabidi[u2].IsEmpty() ;
|
|
break ;
|
|
} ;
|
|
} ;
|
|
} ;
|
|
|
|
// If this is not the first time this page has been used, any changes made
|
|
// could affect the data managed by some of the other pages. Make a call
|
|
// to fixup that data when needed.
|
|
|
|
m_pciwParent->BiDiDataChanged() ;
|
|
|
|
// All went well so move on to the next wizard page.
|
|
|
|
return CPropertyPage::OnWizardNext() ;
|
|
}
|
|
|
|
|
|
LRESULT CINFWizBiDi::OnWizardBack()
|
|
{
|
|
// This works because the same thing needs to be done for both
|
|
// OnWizardNext() and OnWizardBack(). In addition,
|
|
// CPropertyPage::OnWizardNext() and CPropertyPage::OnWizardBack() just
|
|
// return 0.
|
|
|
|
return OnWizardNext() ;
|
|
}
|
|
|
|
|
|
void InitListListPage(CListBox& clbmainlst, bool& binit, CINFWizard* pciwparent,
|
|
CObArray& coapermaindata,
|
|
CFullEditListCtrl& cfelcsecondlst, int ncollabid,
|
|
CStringArray& csamain, bool& breinitwdata,
|
|
int& ncurmodelidx, int neditlen, DWORD dwmiscflags)
|
|
{
|
|
clbmainlst.SetFocus() ; // The main list box gets the focus
|
|
|
|
// Nothing else need be done if this page has been initialized already and
|
|
// it has not be requested to reinitialize itself while keeping existing
|
|
// data.
|
|
|
|
if (binit && !breinitwdata)
|
|
return ;
|
|
|
|
// Count the array of items to load into the main list box.
|
|
|
|
unsigned unummodels = (unsigned)csamain.GetSize() ;
|
|
|
|
// Load the main items into the main list box.
|
|
|
|
clbmainlst.ResetContent() ;
|
|
for (unsigned u = 0 ; u < unummodels ; u++)
|
|
clbmainlst.AddString(csamain[u]) ;
|
|
|
|
CStringArray* pcsa ;
|
|
|
|
// Initialize the array of string array pointers used to manage the data
|
|
// in the second list for each item in the main list. (Only if not
|
|
// reinitializing because the existing data must be maintained in this
|
|
// case.)
|
|
|
|
if (!breinitwdata) {
|
|
coapermaindata.SetSize(unummodels) ;
|
|
for (u = 0 ; u < unummodels ; u++) {
|
|
pcsa = new CStringArray ;
|
|
pcsa->RemoveAll() ;
|
|
coapermaindata[u] = (CObArray*) pcsa ;
|
|
} ;
|
|
} ;
|
|
|
|
// Initialize the list control
|
|
|
|
cfelcsecondlst.InitControl(LVS_EX_FULLROWSELECT+LVS_EX_GRIDLINES, 8, 1, 0,
|
|
neditlen, dwmiscflags) ;
|
|
|
|
// Put some bogus entries into a string array that is used to "activate"
|
|
// the list control.
|
|
|
|
pcsa = new CStringArray ;
|
|
pcsa->SetSize(8) ;
|
|
for (u = 0 ; u < 8 ; u++)
|
|
pcsa->SetAt(u, csEmpty) ;
|
|
|
|
// Initialize the only column in the list control.
|
|
|
|
CString cstmp ;
|
|
cstmp.LoadString(ncollabid) ;
|
|
cfelcsecondlst.InitLoadColumn(0, cstmp, SETWIDTHTOREMAINDER, -16, true,
|
|
true, COLDATTYPE_STRING, (CObArray*) pcsa) ;
|
|
delete pcsa ;
|
|
|
|
// Now that the list control has been initialized, disable it until a main
|
|
// list item is selected.
|
|
|
|
cfelcsecondlst.EnableWindow(false) ;
|
|
|
|
ncurmodelidx = -1 ; // Reset the current model index
|
|
binit = true ; // Page is initialized now
|
|
breinitwdata = false ; // Reinit (if needed) is done now on this page
|
|
return ;
|
|
}
|
|
|
|
|
|
void SelChangedListListPage(CListBox& clbmainlst, bool binit,
|
|
CObArray& coapermaindata,
|
|
CFullEditListCtrl& cfelcsecondlst,
|
|
CButton* pcbbrowse, int& ncurmainidx)
|
|
{
|
|
// Do nothing if the page has not been initialized yet.
|
|
|
|
if (!binit)
|
|
return ;
|
|
|
|
// Make sure the Profiles list and Browse button are enabled.
|
|
|
|
if (pcbbrowse != NULL)
|
|
pcbbrowse->EnableWindow() ;
|
|
cfelcsecondlst.EnableWindow() ;
|
|
|
|
// If there was a previous selection in the list box, save that model's
|
|
// filespecs before loading the current model's filespecs.
|
|
|
|
CStringArray* pcsa ;
|
|
if (ncurmainidx != -1) {
|
|
cfelcsecondlst.SaveValue() ;
|
|
pcsa = (CStringArray*) coapermaindata[ncurmainidx] ;
|
|
cfelcsecondlst.GetColumnData((CObArray*) pcsa, 0) ;
|
|
} ;
|
|
|
|
// Update the current model index and load its filespecs into the list
|
|
// control. Before loading, make sure that the current model's file array
|
|
// is long enough to overwrite all of the last model's file strings that
|
|
// are currently in the list.
|
|
|
|
if ((ncurmainidx = clbmainlst.GetCurSel()) != -1) {
|
|
pcsa = (CStringArray*) coapermaindata[ncurmainidx] ;
|
|
int nelts = (int)pcsa->GetSize() ;
|
|
int nrows = cfelcsecondlst.GetItemCount() ;
|
|
if (nelts < nrows) {
|
|
pcsa->SetSize(nrows) ;
|
|
for (int n = nrows ; n < nelts ; n++)
|
|
pcsa->SetAt(n, csEmpty) ;
|
|
} ;
|
|
cfelcsecondlst.SetColumnData((CObArray*) pcsa, 0) ;
|
|
} ;
|
|
}
|
|
|
|
|
|
void OnBrowseListListPage(CFullEditListCtrl& cfelcsecondlst, int nfiletypeid)
|
|
{
|
|
// Prepare for and prompt the user for a filespec to add to the list
|
|
// control. Return if the user cancels.
|
|
|
|
CString cstmp ;
|
|
cstmp.LoadString(nfiletypeid) ;
|
|
CFileDialog cfd(TRUE, NULL, NULL, OFN_FILEMUSTEXIST, cstmp) ;
|
|
if (cfd.DoModal() != IDOK)
|
|
return ;
|
|
|
|
// Get the user selected filespec.
|
|
|
|
cstmp = cfd.GetPathName() ;
|
|
|
|
// Determine the row to place the filespec in
|
|
|
|
int nrow ;
|
|
if ((nrow = cfelcsecondlst.GetNextItem(-1, LVNI_SELECTED)) == -1)
|
|
nrow = 0 ;
|
|
|
|
// Save the filespec in the profiles list
|
|
|
|
VERIFY(cfelcsecondlst.SetItemText(nrow, 0, cstmp)) ;
|
|
}
|
|
|
|
|
|
void OnWizNextListListPage(int& ncurmainidx, CFullEditListCtrl& cfelcsecondlst,
|
|
CObArray& coapermaindata)
|
|
{
|
|
// If there was a previous selection in the list box, save that item's
|
|
// data.
|
|
|
|
CStringArray* pcsa ;
|
|
if (ncurmainidx != -1) {
|
|
cfelcsecondlst.SaveValue() ;
|
|
pcsa = (CStringArray*) coapermaindata[ncurmainidx] ;
|
|
cfelcsecondlst.GetColumnData((CObArray*) pcsa, 0) ;
|
|
} ;
|
|
|
|
// Users may not fill every string in the string arrays so get rid of the
|
|
// ones that are empty.
|
|
|
|
int nnummodels = (int)coapermaindata.GetSize() ;
|
|
int nnumfiles, n, n2, n3 ;
|
|
for (n = 0 ; n < nnummodels ; n++) {
|
|
pcsa = (CStringArray*) coapermaindata[n] ;
|
|
nnumfiles = (int)pcsa->GetSize() ;
|
|
for (n2 = n3 = 0 ; n2 < nnumfiles ; n2++) {
|
|
(pcsa->GetAt(n3)).TrimLeft() ;
|
|
(pcsa->GetAt(n3)).TrimRight() ;
|
|
if ((pcsa->GetAt(n3)).IsEmpty())
|
|
pcsa->RemoveAt(n3) ;
|
|
else
|
|
n3++ ;
|
|
} ;
|
|
} ;
|
|
}
|
|
|
|
|
|
void ModelChangeFixupsListListPage(unsigned unummodelssel,
|
|
CStringArray& csamodels,
|
|
CStringArray& csamodelslast,
|
|
CFullEditListCtrl& cfelcsecondlst,
|
|
CObArray& coapermaindata, int& ncurmainidx,
|
|
CButton* pcbbrowse, CListBox& clbmainlst,
|
|
bool& breinitwdata)
|
|
{
|
|
// Declare looping vars, get the size of the old selection array, and
|
|
// declare / size / initialize a new profiles array.
|
|
|
|
unsigned u, u2, unumlst, unumrows, unumold ;
|
|
unumlst = (unsigned) csamodelslast.GetSize() ;
|
|
if ((unumrows = cfelcsecondlst.GetItemCount()) == 0)
|
|
unumrows = 8 ;
|
|
CObArray coaprofarrays ;
|
|
CStringArray *pcsa, *pcsaold ;
|
|
coaprofarrays.SetSize(unummodelssel) ;
|
|
for (u = 0 ; u < unummodelssel ; u++) {
|
|
pcsa = new CStringArray ;
|
|
pcsa->SetSize(unumrows) ;
|
|
for (u2 = 0 ; u2 < unumrows ; u2++)
|
|
pcsa->SetAt(u2, csEmpty) ;
|
|
coaprofarrays[u] = (CObArray*) pcsa ;
|
|
} ;
|
|
|
|
// Clear the list control if not reinitializing.
|
|
|
|
if (!breinitwdata)
|
|
cfelcsecondlst.SetColumnData((CObArray*) coaprofarrays[0], 0) ;
|
|
|
|
// Try to find each new model in the list of old models. If found, copy the
|
|
// old model's data to the new profiles array.
|
|
|
|
for (u = 0 ; u < unummodelssel ; u++) {
|
|
for (u2 = 0 ; u2 < unumlst ; u2++) {
|
|
if (csamodels[u] == csamodelslast[u2])
|
|
break ;
|
|
} ;
|
|
if (u2 < unumlst) {
|
|
pcsa = (CStringArray*) coaprofarrays[u] ;
|
|
pcsaold = (CStringArray*) coapermaindata[u2] ;
|
|
unumold = (unsigned)pcsaold->GetSize() ;
|
|
for (u2 = 0 ; u2 < unumold ; u2++)
|
|
pcsa->SetAt(u2, pcsaold->GetAt(u2)) ;
|
|
} ;
|
|
} ;
|
|
|
|
// Delete all of the old data
|
|
|
|
for (u = 0 ; u < (unsigned) coapermaindata.GetSize() ; u++) {
|
|
pcsaold = (CStringArray*) coapermaindata[u] ;
|
|
delete pcsaold ;
|
|
} ;
|
|
|
|
// Copy the new data into the member variable
|
|
|
|
coapermaindata.SetSize(unummodelssel) ;
|
|
for (u = 0 ; u < unummodelssel ; u++)
|
|
coapermaindata[u] = coaprofarrays[u] ;
|
|
|
|
// Now that the data structures are up to date, finish updating the page's
|
|
// controls.
|
|
|
|
ncurmainidx = -1 ;
|
|
cfelcsecondlst.EnableWindow(false) ;
|
|
pcbbrowse->EnableWindow(false) ;
|
|
clbmainlst.ResetContent() ;
|
|
for (u = 0 ; u < unummodelssel ; u++)
|
|
clbmainlst.AddString(csamodels[u]) ;
|
|
clbmainlst.SetCurSel(-1) ;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizICMProfiles property page
|
|
|
|
IMPLEMENT_DYNCREATE(CINFWizICMProfiles, CPropertyPage)
|
|
|
|
CINFWizICMProfiles::CINFWizICMProfiles() : CPropertyPage(CINFWizICMProfiles::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CINFWizICMProfiles)
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bInitialized = m_bReInitWData = m_bSelChanged = false ;
|
|
m_nCurModelIdx = -1 ;
|
|
}
|
|
|
|
CINFWizICMProfiles::~CINFWizICMProfiles()
|
|
{
|
|
// Delete the string arrays referenced in m_coaProfileArrays.
|
|
|
|
CStringArray* pcsa ;
|
|
for (int n = 0 ; n < m_coaProfileArrays.GetSize() ; n++) {
|
|
pcsa = (CStringArray*) m_coaProfileArrays[n] ;
|
|
delete pcsa ;
|
|
} ;
|
|
}
|
|
|
|
void CINFWizICMProfiles::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPage::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CINFWizICMProfiles)
|
|
DDX_Control(pDX, IDC_ICMFSpecsLst, m_cfelcICMFSpecs);
|
|
DDX_Control(pDX, IDC_ModelsLst, m_clbModels);
|
|
DDX_Control(pDX, IDC_BrowseBtn, m_cbBrowse);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
void CINFWizICMProfiles::ModelChangeFixups(unsigned unummodelssel,
|
|
CStringArray& csamodels,
|
|
CStringArray& csamodelslast)
|
|
{
|
|
// Do nothing if the page has not been initialized yet.
|
|
|
|
if (!m_bInitialized)
|
|
return ;
|
|
|
|
// See ModelChangeFixupsListListPage() for more information.
|
|
|
|
ModelChangeFixupsListListPage(unummodelssel, csamodels, csamodelslast,
|
|
m_cfelcICMFSpecs, m_coaProfileArrays,
|
|
m_nCurModelIdx, &m_cbBrowse, m_clbModels,
|
|
m_bReInitWData) ;
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFWizICMProfiles, CPropertyPage)
|
|
//{{AFX_MSG_MAP(CINFWizICMProfiles)
|
|
ON_BN_CLICKED(IDC_BrowseBtn, OnBrowseBtn)
|
|
ON_LBN_SELCHANGE(IDC_ModelsLst, OnSelchangeModelsLst)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizICMProfiles message handlers
|
|
|
|
BOOL CINFWizICMProfiles::OnSetActive()
|
|
{
|
|
// Get the list of models to load into the main list box.
|
|
|
|
CStringArray& csamodels = m_pciwParent->GetINFModels() ;
|
|
|
|
// Nothing else need be done if this page has been initialized already
|
|
// and it is not being asked to reinitialize the page... That is,
|
|
// except for possibly needing to pick up any selected model changes
|
|
// that were made.
|
|
|
|
if (m_bInitialized && !m_bReInitWData) {
|
|
if (m_bSelChanged) {
|
|
ModelChangeFixups(m_pciwParent->GetINFModsSelCount(), csamodels,
|
|
m_pciwParent->GetINFModelsLst()) ;
|
|
m_bSelChanged = false ;
|
|
} ;
|
|
return CPropertyPage::OnSetActive() ;
|
|
} ;
|
|
|
|
// Pick up selected model changes when reinitializing
|
|
|
|
if (m_bReInitWData) {
|
|
ModelChangeFixups(m_pciwParent->GetINFModsSelCount(), csamodels,
|
|
m_pciwParent->GetINFModelsLst()) ;
|
|
m_bSelChanged = false ;
|
|
} ;
|
|
|
|
// See InitListListPage() for more details.
|
|
|
|
InitListListPage(m_clbModels, m_bInitialized, m_pciwParent,
|
|
m_coaProfileArrays, m_cfelcICMFSpecs, IDS_INFICMColLab,
|
|
csamodels, m_bReInitWData, m_nCurModelIdx, 256, 0) ;
|
|
return CPropertyPage::OnSetActive() ;
|
|
}
|
|
|
|
|
|
void CINFWizICMProfiles::OnSelchangeModelsLst()
|
|
{
|
|
SelChangedListListPage(m_clbModels, m_bInitialized, m_coaProfileArrays,
|
|
m_cfelcICMFSpecs, &m_cbBrowse, m_nCurModelIdx) ;
|
|
}
|
|
|
|
|
|
void CINFWizICMProfiles::OnBrowseBtn()
|
|
{
|
|
// See OnBrowseListListPage() for more information.
|
|
|
|
OnBrowseListListPage(m_cfelcICMFSpecs, IDS_CommonICMFile) ;
|
|
}
|
|
|
|
|
|
LRESULT CINFWizICMProfiles::OnWizardNext()
|
|
{
|
|
// Do nothing if the page has not been initialized yet.
|
|
|
|
if (!m_bInitialized)
|
|
return -1 ;
|
|
|
|
// See OnWizNextListListPage() for more information.
|
|
|
|
OnWizNextListListPage(m_nCurModelIdx, m_cfelcICMFSpecs, m_coaProfileArrays);
|
|
return CPropertyPage::OnWizardNext() ;
|
|
}
|
|
|
|
|
|
LRESULT CINFWizICMProfiles::OnWizardBack()
|
|
{
|
|
// This works because the same thing needs to be done for both
|
|
// OnWizardNext() and OnWizardBack(). In addition,
|
|
// CPropertyPage::OnWizardNext() and CPropertyPage::OnWizardBack() just
|
|
// return 0.
|
|
|
|
return OnWizardNext() ;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizIncludeFiles property page
|
|
|
|
IMPLEMENT_DYNCREATE(CINFWizIncludeFiles, CPropertyPage)
|
|
|
|
CINFWizIncludeFiles::CINFWizIncludeFiles() : CPropertyPage(CINFWizIncludeFiles::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CINFWizIncludeFiles)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bInitialized = m_bReInitWData = m_bSelChanged = false ;
|
|
m_nCurModelIdx = -1 ;
|
|
}
|
|
|
|
CINFWizIncludeFiles::~CINFWizIncludeFiles()
|
|
{
|
|
}
|
|
|
|
void CINFWizIncludeFiles::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPage::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CINFWizIncludeFiles)
|
|
DDX_Control(pDX, IDC_ModelsLst, m_clbModels);
|
|
DDX_Control(pDX, IDC_IncludeFileBox, m_ceIncludeFile);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFWizIncludeFiles, CPropertyPage)
|
|
//{{AFX_MSG_MAP(CINFWizIncludeFiles)
|
|
ON_LBN_SELCHANGE(IDC_ModelsLst, OnSelchangeModelsLst)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizIncludeFiles message handlers
|
|
|
|
BOOL CINFWizIncludeFiles::OnSetActive()
|
|
{
|
|
// Just perform the default actions if nothing special needs to be done.
|
|
|
|
if (m_bInitialized && (!m_bReInitWData) && (!m_bSelChanged))
|
|
return CPropertyPage::OnSetActive() ;
|
|
|
|
int n, n2 ; // Looping variable
|
|
int numelts, newnumelts ; // Number of elements in an array
|
|
CString cstmp ; // Temp string
|
|
|
|
// Perform the first time initialization.
|
|
|
|
if (!m_bInitialized) {
|
|
// Get a copy of the currently selected model names and then load them
|
|
// into the list box. Set the focus to the list box.
|
|
|
|
m_csaModels.Copy(m_pciwParent->GetINFModels()) ;
|
|
for (n = 0, numelts = (int) m_csaModels.GetSize() ; n < numelts ; n++)
|
|
m_clbModels.AddString(m_csaModels[n]) ;
|
|
m_clbModels.SetFocus() ;
|
|
|
|
// Size and initialize the include files array. Initialize each
|
|
// include file to the default.
|
|
|
|
cstmp.LoadString(IDS_DefINFIncFile) ;
|
|
m_csaIncFiles.SetSize(numelts) ;
|
|
for (n = 0 ; n < numelts ; n++)
|
|
m_csaIncFiles[n] = cstmp ;
|
|
|
|
// Set init flag, reset other flags, and return whatever the base class
|
|
// function returns.
|
|
|
|
m_bInitialized = true ;
|
|
m_bReInitWData = m_bSelChanged = false ;
|
|
return CPropertyPage::OnSetActive() ;
|
|
} ;
|
|
|
|
// Either the selected models have changed or the wizard is being
|
|
// reinitialized if this point is reached. Both are handled the same way.
|
|
//
|
|
// Begin by getting info about the models in this page and the ones that
|
|
// are selected now.
|
|
|
|
CStringArray& csanewmodels = m_pciwParent->GetINFModels() ;
|
|
CUIntArray cuiaoldmodelsfound, cuianewmodelsfound ;
|
|
numelts = IdentifyOldAndNewModels(csanewmodels, cuiaoldmodelsfound,
|
|
cuianewmodelsfound, newnumelts,
|
|
m_csaModels) ;
|
|
|
|
// Remove the old models and related data that are no longer needed.
|
|
|
|
for (n = numelts - 1 ; n >= 0 ; n--)
|
|
if (cuiaoldmodelsfound[n] == 0) {
|
|
m_csaModels.RemoveAt(n) ;
|
|
m_csaIncFiles.RemoveAt(n) ;
|
|
} ;
|
|
|
|
// Add the truly new models to this page's array of model names and
|
|
// initialize an Include File string for it.
|
|
|
|
cstmp.LoadString(IDS_DefINFIncFile) ;
|
|
for (n = n2 = 0 ; n < newnumelts ; n++) {
|
|
if (cuianewmodelsfound[n] == 1) {
|
|
n2++ ;
|
|
continue ;
|
|
} ;
|
|
m_csaModels.InsertAt(n2, csanewmodels[n]) ;
|
|
m_csaIncFiles.InsertAt(n2, cstmp) ;
|
|
} ;
|
|
|
|
// Clear the Include Files edit box
|
|
|
|
m_ceIncludeFile.SetWindowText(csEmpty) ;
|
|
|
|
// Reinitialize the models array and the current model index.
|
|
|
|
m_clbModels.ResetContent() ;
|
|
for (n = 0, numelts = (int) m_csaModels.GetSize() ; n < numelts ; n++)
|
|
m_clbModels.AddString(m_csaModels[n]) ;
|
|
m_clbModels.SetCurSel(-1) ;
|
|
m_clbModels.SetFocus() ;
|
|
m_nCurModelIdx = -1 ;
|
|
|
|
// Set init flag, reset other flags, and return whatever the base class
|
|
// function returns.
|
|
|
|
m_bInitialized = true ;
|
|
m_bReInitWData = m_bSelChanged = false ;
|
|
return CPropertyPage::OnSetActive() ;
|
|
}
|
|
|
|
|
|
void CINFWizIncludeFiles::OnSelchangeModelsLst()
|
|
{
|
|
// If there was a previous model selection, save its include file string.
|
|
// Otherwise, enable the include file edit box.
|
|
|
|
if (m_nCurModelIdx != -1)
|
|
m_ceIncludeFile.GetWindowText(m_csaIncFiles[m_nCurModelIdx]) ;
|
|
else
|
|
m_ceIncludeFile.EnableWindow() ;
|
|
|
|
// Save the index for the currently selected model. Then load the edit box
|
|
// with the include file string for that model.
|
|
|
|
m_nCurModelIdx = m_clbModels.GetCurSel() ;
|
|
m_ceIncludeFile.SetWindowText(m_csaIncFiles[m_nCurModelIdx]) ;
|
|
}
|
|
|
|
|
|
LRESULT CINFWizIncludeFiles::OnWizardNext()
|
|
{
|
|
// Save the index for the currently selected model. If the value is valid,
|
|
// save the include file string for this model.
|
|
|
|
if ((m_nCurModelIdx = m_clbModels.GetCurSel()) != -1)
|
|
m_ceIncludeFile.GetWindowText(m_csaIncFiles[m_nCurModelIdx]) ;
|
|
|
|
// Make sure each model has an include file string. Complain and exit
|
|
// without allowing the page to change if an empty string is found.
|
|
|
|
int numelts = (int) m_csaIncFiles.GetSize() ;
|
|
for (int n = 0 ; n < numelts ; n++) {
|
|
if (m_csaIncFiles[n].IsEmpty()) {
|
|
CString cserrmsg ;
|
|
cserrmsg.Format(IDS_INFMissingIncError, m_csaModels[n]) ;
|
|
AfxMessageBox(cserrmsg, MB_ICONEXCLAMATION) ;
|
|
m_clbModels.SetCurSel(n) ;
|
|
OnSelchangeModelsLst() ;
|
|
m_ceIncludeFile.SetFocus() ;
|
|
return -1 ;
|
|
} ;
|
|
} ;
|
|
|
|
// All went well so...
|
|
|
|
return CPropertyPage::OnWizardNext();
|
|
}
|
|
|
|
|
|
LRESULT CINFWizIncludeFiles::OnWizardBack()
|
|
{
|
|
// This works because the same thing needs to be done for both
|
|
// OnWizardNext() and OnWizardBack(). In addition,
|
|
// CPropertyPage::OnWizardNext() and CPropertyPage::OnWizardBack() just
|
|
// return 0.
|
|
|
|
return OnWizardNext() ;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizInstallSections property page
|
|
|
|
IMPLEMENT_DYNCREATE(CINFWizInstallSections, CPropertyPage)
|
|
|
|
CINFWizInstallSections::CINFWizInstallSections() : CPropertyPage(CINFWizInstallSections::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CINFWizInstallSections)
|
|
m_csOtherSections = _T("");
|
|
m_bOther = FALSE;
|
|
m_bPscript = FALSE;
|
|
m_bTtfsub = FALSE;
|
|
m_bUnidrvBidi = FALSE;
|
|
m_bUnidrv = FALSE;
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bInitialized = m_bReInitWData = m_bSelChanged = false ;
|
|
m_nCurModelIdx = -1 ;
|
|
}
|
|
|
|
|
|
CINFWizInstallSections::~CINFWizInstallSections()
|
|
{
|
|
// Delete the flag arrays referenced in m_coaStdInstSecs.
|
|
|
|
CUIntArray* pcuia ;
|
|
for (int n = 0 ; n < m_coaStdInstSecs.GetSize() ; n++) {
|
|
pcuia = (CUIntArray*) m_coaStdInstSecs[n] ;
|
|
delete pcuia ;
|
|
} ;
|
|
}
|
|
|
|
|
|
void CINFWizInstallSections::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPage::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CINFWizInstallSections)
|
|
DDX_Control(pDX, IDC_ModelsLst, m_clbModels);
|
|
DDX_Text(pDX, IDC_OtherBox, m_csOtherSections);
|
|
DDX_Check(pDX, IDC_OtherChk, m_bOther);
|
|
DDX_Check(pDX, IDC_PscriptChk, m_bPscript);
|
|
DDX_Check(pDX, IDC_TtfsubChk, m_bTtfsub);
|
|
DDX_Check(pDX, IDC_UnidrvBidiChk, m_bUnidrvBidi);
|
|
DDX_Check(pDX, IDC_UnidrvChk, m_bUnidrv);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFWizInstallSections, CPropertyPage)
|
|
//{{AFX_MSG_MAP(CINFWizInstallSections)
|
|
ON_LBN_SELCHANGE(IDC_ModelsLst, OnSelchangeModelsLst)
|
|
ON_BN_CLICKED(IDC_OtherChk, OnOtherChk)
|
|
ON_BN_CLICKED(IDC_PscriptChk, OnPscriptChk)
|
|
ON_BN_CLICKED(IDC_TtfsubChk, OnTtfsubChk)
|
|
ON_BN_CLICKED(IDC_UnidrvBidiChk, OnUnidrvBidiChk)
|
|
ON_BN_CLICKED(IDC_UnidrvChk, OnUnidrvChk)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizInstallSections message handlers
|
|
|
|
BOOL CINFWizInstallSections::OnSetActive()
|
|
{
|
|
// Just perform the default actions if nothing special needs to be done.
|
|
|
|
if (m_bInitialized && (!m_bReInitWData) && (!m_bSelChanged))
|
|
return CPropertyPage::OnSetActive() ;
|
|
|
|
int n, n2 ; // Looping variable
|
|
int numelts, newnumelts ; // Number of elements in an array
|
|
CUIntArray* pcuia ; // Used to reference a model's flags array
|
|
|
|
// Perform the first time initialization.
|
|
|
|
if (!m_bInitialized) {
|
|
// Get a copy of the currently selected model names and initialize the
|
|
// controls on this page.
|
|
|
|
m_csaModels.Copy(m_pciwParent->GetINFModels()) ;
|
|
numelts = InitPageControls() ;
|
|
|
|
// Size and initialize the standard install sections array. There is
|
|
// one entry in the array per model. Each entry references an array
|
|
// of flags that specify the install sections for each model. See
|
|
// below to see how the flags are initialized.
|
|
//
|
|
// The other install sections string array is sized and initialized too.
|
|
|
|
m_coaStdInstSecs.SetSize(numelts) ;
|
|
m_csaOtherInstSecs.SetSize(numelts) ;
|
|
for (n = 0 ; n < numelts ; n++)
|
|
AddModelFlags(n) ;
|
|
|
|
// Set init flag, reset other flags, and return whatever the base class
|
|
// function returns.
|
|
|
|
m_bInitialized = true ;
|
|
m_bReInitWData = m_bSelChanged = false ;
|
|
return CPropertyPage::OnSetActive() ;
|
|
} ;
|
|
|
|
// Either the selected models have changed or the wizard is being
|
|
// reinitialized if this point is reached. Both are handled the same way.
|
|
//
|
|
// Begin by getting info about the models in this page and the ones that
|
|
// are selected now.
|
|
|
|
CStringArray& csanewmodels = m_pciwParent->GetINFModels() ;
|
|
CUIntArray cuiaoldmodelsfound, cuianewmodelsfound ;
|
|
numelts = IdentifyOldAndNewModels(csanewmodels, cuiaoldmodelsfound,
|
|
cuianewmodelsfound, newnumelts,
|
|
m_csaModels) ;
|
|
|
|
// Remove the old models and related data that are no longer needed.
|
|
|
|
for (n = numelts - 1 ; n >= 0 ; n--)
|
|
if (cuiaoldmodelsfound[n] == 0) {
|
|
m_csaModels.RemoveAt(n) ;
|
|
pcuia = (CUIntArray*) m_coaStdInstSecs[n] ;
|
|
delete pcuia ;
|
|
m_coaStdInstSecs.RemoveAt(n) ;
|
|
m_csaOtherInstSecs.RemoveAt(n) ;
|
|
} ;
|
|
|
|
// Add the truly new models to this page's array of model names and
|
|
// initialize all related Install Section data for it.
|
|
|
|
for (n = n2 = 0 ; n < newnumelts ; n++) {
|
|
if (cuianewmodelsfound[n] == 1) {
|
|
n2++ ;
|
|
continue ;
|
|
} ;
|
|
m_csaModels.InsertAt(n2, csanewmodels[n]) ;
|
|
m_coaStdInstSecs.InsertAt(n2, (CObject*) NULL) ;
|
|
m_csaOtherInstSecs.InsertAt(n2, csEmpty) ;
|
|
AddModelFlags(n2) ;
|
|
} ;
|
|
|
|
// Initialize the controls on the page
|
|
|
|
InitPageControls() ;
|
|
|
|
// Set init flag, reset other flags, and return whatever the base class
|
|
// function returns.
|
|
|
|
m_bInitialized = true ;
|
|
m_bReInitWData = m_bSelChanged = false ;
|
|
return CPropertyPage::OnSetActive() ;
|
|
}
|
|
|
|
|
|
void CINFWizInstallSections::AddModelFlags(int nidx)
|
|
{
|
|
int n ; // Looping variable
|
|
CUIntArray* pcuia ; // Used to reference a model's flags array
|
|
CString csfname ; // Model's file name
|
|
|
|
// Allocate the flags array and save it in the array of flags arrays.
|
|
// Next, initialize the other sections string for this model.
|
|
|
|
pcuia = new CUIntArray ;
|
|
m_coaStdInstSecs[nidx] = (CObArray*) pcuia ;
|
|
m_csaOtherInstSecs[nidx].Empty() ;
|
|
|
|
// Size the current flags array and initialize each one to 0 (off).
|
|
|
|
pcuia->SetSize(NUMINSTSECFLAGS) ;
|
|
for (n = 0 ; n < NUMINSTSECFLAGS ; n++)
|
|
(*pcuia)[n] = 0 ;
|
|
|
|
// Get the model's file name and check its extension to see if
|
|
// one of its Unidrv or its PostScript flag should be set. (The
|
|
// other flags are only user settable so they aren't changed.)
|
|
//RAID 0001
|
|
csfname = m_pciwParent->GetModelFile(m_csaModels[nidx]) ;
|
|
if (csfname.Find(_T(".GPD")) != -1) {
|
|
// The UNIDRVBIDI section is used (flagged) if the user marked
|
|
// this model BIDI. Otherwise, the UNIDRV section is used.
|
|
|
|
if (m_pciwParent->m_ciwbd.m_cuaBiDiFlags[nidx])
|
|
(*pcuia)[ISF_UNIBIDI] = 1 ;
|
|
else
|
|
(*pcuia)[ISF_UNI] = 1 ;
|
|
|
|
// Postcript file.
|
|
|
|
} else
|
|
(*pcuia)[ISF_PSCR] = 1 ;
|
|
}
|
|
|
|
|
|
int CINFWizInstallSections::InitPageControls()
|
|
{
|
|
int n ; // Looping variable
|
|
int numelts ; // Number of elements in an array
|
|
|
|
// Load the current set of models into the list box
|
|
|
|
m_clbModels.ResetContent() ;
|
|
for (n = 0, numelts = (int) m_csaModels.GetSize() ; n < numelts ; n++)
|
|
m_clbModels.AddString(m_csaModels[n]) ;
|
|
|
|
// Make sure there is no model selected in the list box and that the box
|
|
// has the focus.
|
|
|
|
m_clbModels.SetCurSel(-1) ;
|
|
m_clbModels.SetFocus() ;
|
|
m_nCurModelIdx = -1 ;
|
|
|
|
// Clear and disable all of the check boxes and the Other edit box.
|
|
|
|
for (n = IDC_UnidrvChk ; n <= IDC_TtfsubChk ; n++)
|
|
GetDlgItem(n)->EnableWindow(FALSE) ;
|
|
GetDlgItem(IDC_OtherBox)->EnableWindow(FALSE) ;
|
|
m_bUnidrv = m_bUnidrvBidi = m_bPscript = m_bTtfsub = m_bOther = FALSE ;
|
|
m_csOtherSections = csEmpty ;
|
|
UpdateData(FALSE) ;
|
|
|
|
// Return the number of elements in the list box. Ie, the number of
|
|
// selected models.
|
|
|
|
return numelts ;
|
|
}
|
|
|
|
|
|
LRESULT CINFWizInstallSections::OnWizardNext()
|
|
{
|
|
// Save the index for the currently selected model. If the value is valid,
|
|
// save the install section data for this model.
|
|
|
|
if ((m_nCurModelIdx = m_clbModels.GetCurSel()) != -1) {
|
|
UpdateData(TRUE) ;
|
|
CUIntArray* pcuia = (CUIntArray*) m_coaStdInstSecs[m_nCurModelIdx] ;
|
|
(*pcuia)[ISF_UNI] = (unsigned) m_bUnidrv ;
|
|
(*pcuia)[ISF_UNIBIDI] = (unsigned) m_bUnidrvBidi ;
|
|
(*pcuia)[ISF_PSCR] = (unsigned) m_bPscript ;
|
|
(*pcuia)[ISF_TTF] = (unsigned) m_bTtfsub ;
|
|
if ((*pcuia)[ISF_OTHER] = (unsigned) m_bOther)
|
|
m_csaOtherInstSecs[m_nCurModelIdx] = m_csOtherSections ;
|
|
} ;
|
|
|
|
// Make sure that each model has one of the main sections selected and, if
|
|
// the Other section was selected, it has an Other string.
|
|
|
|
CString cserrmsg ;
|
|
CUIntArray* pcuia ;
|
|
int numelts = (int) m_csaModels.GetSize() ;
|
|
for (int n = 0 ; n < numelts ; n++) {
|
|
pcuia = (CUIntArray*) m_coaStdInstSecs[n] ;
|
|
TRACE("*** %s: ISF_UNI=%d ISF_UNIBIDI=%d ISF_PSCR=%d ISF_OTHER=%d\n", m_csaModels[n], (*pcuia)[ISF_UNI], (*pcuia)[ISF_UNIBIDI], (*pcuia)[ISF_PSCR], (*pcuia)[ISF_OTHER]) ;
|
|
if ((*pcuia)[ISF_UNI] == 0 && (*pcuia)[ISF_UNIBIDI] == 0
|
|
&& (*pcuia)[ISF_PSCR] == 0 && (*pcuia)[ISF_OTHER] == 0) {
|
|
cserrmsg.Format(IDS_INFMissingInstSecError, m_csaModels[n]) ;
|
|
AfxMessageBox(cserrmsg, MB_ICONEXCLAMATION) ;
|
|
m_clbModels.SetCurSel(n) ;
|
|
OnSelchangeModelsLst() ;
|
|
return -1 ;
|
|
} ;
|
|
if ((*pcuia)[ISF_OTHER] && m_csaOtherInstSecs[n].IsEmpty()) {
|
|
cserrmsg.Format(IDS_INFNoOtherStrError, m_csaModels[n]) ;
|
|
AfxMessageBox(cserrmsg, MB_ICONEXCLAMATION) ;
|
|
m_clbModels.SetCurSel(n) ;
|
|
OnSelchangeModelsLst() ;
|
|
return -1 ;
|
|
} ;
|
|
} ;
|
|
|
|
// All went well so...
|
|
|
|
return CPropertyPage::OnWizardNext();
|
|
}
|
|
|
|
|
|
LRESULT CINFWizInstallSections::OnWizardBack()
|
|
{
|
|
// This works because the same thing needs to be done for both
|
|
// OnWizardNext() and OnWizardBack(). In addition,
|
|
// CPropertyPage::OnWizardNext() and CPropertyPage::OnWizardBack() just
|
|
// return 0.
|
|
|
|
return OnWizardNext() ;
|
|
}
|
|
|
|
|
|
void CINFWizInstallSections::OnSelchangeModelsLst()
|
|
{
|
|
// If there was a previous model selection, save its install section flags.
|
|
// Otherwise, enable the install section check boxes.
|
|
|
|
if (m_nCurModelIdx != -1) {
|
|
UpdateData(TRUE) ;
|
|
CUIntArray* pcuia = (CUIntArray*) m_coaStdInstSecs[m_nCurModelIdx] ;
|
|
(*pcuia)[ISF_UNI] = (unsigned) m_bUnidrv ;
|
|
(*pcuia)[ISF_UNIBIDI] = (unsigned) m_bUnidrvBidi ;
|
|
(*pcuia)[ISF_PSCR] = (unsigned) m_bPscript ;
|
|
(*pcuia)[ISF_TTF] = (unsigned) m_bTtfsub ;
|
|
if ((*pcuia)[ISF_OTHER] = (unsigned) m_bOther)
|
|
m_csaOtherInstSecs[m_nCurModelIdx] = m_csOtherSections ;
|
|
} else {
|
|
for (int n = IDC_UnidrvChk ; n <= IDC_TtfsubChk ; n++)
|
|
GetDlgItem(n)->EnableWindow(TRUE) ;
|
|
} ;
|
|
|
|
// Save the index for the currently selected model. Then set the check
|
|
// boxes based on the flags for the specified model.
|
|
|
|
m_nCurModelIdx = m_clbModels.GetCurSel() ;
|
|
CUIntArray* pcuia = (CUIntArray*) m_coaStdInstSecs[m_nCurModelIdx] ;
|
|
m_bUnidrv = (BOOL) ((*pcuia)[ISF_UNI]) ;
|
|
m_bUnidrvBidi = (BOOL) ((*pcuia)[ISF_UNIBIDI]) ;
|
|
m_bPscript = (BOOL) ((*pcuia)[ISF_PSCR]) ;
|
|
m_bTtfsub = (BOOL) ((*pcuia)[ISF_TTF]) ;
|
|
if (m_bOther = (BOOL) ((*pcuia)[ISF_OTHER]))
|
|
m_csOtherSections = m_csaOtherInstSecs[m_nCurModelIdx] ;
|
|
else
|
|
m_csOtherSections = csEmpty ;
|
|
GetDlgItem(IDC_OtherBox)->EnableWindow(m_bOther) ;
|
|
UpdateData(FALSE) ;
|
|
}
|
|
|
|
|
|
void CINFWizInstallSections::OnPscriptChk()
|
|
{
|
|
// If the PostScript checkbox is checked, the Unidrv and TrueType check
|
|
// boxes must be unchecked.
|
|
|
|
UpdateData(TRUE) ;
|
|
if (m_bPscript) {
|
|
m_bTtfsub = m_bUnidrvBidi = m_bUnidrv = FALSE ;
|
|
UpdateData(FALSE) ;
|
|
}
|
|
}
|
|
|
|
|
|
void CINFWizInstallSections::OnTtfsubChk()
|
|
{
|
|
// If the TrueType box is checked, clear the PostScript checkbox.
|
|
|
|
UpdateData(TRUE) ;
|
|
if (m_bTtfsub) {
|
|
m_bPscript = FALSE ;
|
|
UpdateData(FALSE) ;
|
|
}
|
|
}
|
|
|
|
|
|
void CINFWizInstallSections::OnUnidrvBidiChk()
|
|
{
|
|
// If the UNIDRV_BIDI box is checked, the UNIDRV and PostScript flags must
|
|
// be unchecked.
|
|
|
|
UpdateData(TRUE) ;
|
|
if (m_bUnidrvBidi) {
|
|
m_bPscript = m_bUnidrv = FALSE ;
|
|
UpdateData(FALSE) ;
|
|
}
|
|
}
|
|
|
|
|
|
void CINFWizInstallSections::OnUnidrvChk()
|
|
{
|
|
// If the UNIDRV box is checked, the UNIDRV_BIDI and PostScript flags must
|
|
// be unchecked.
|
|
|
|
UpdateData(TRUE) ;
|
|
if (m_bUnidrv) {
|
|
m_bPscript = m_bUnidrvBidi = FALSE ;
|
|
UpdateData(FALSE) ;
|
|
}
|
|
}
|
|
|
|
|
|
void CINFWizInstallSections::OnOtherChk()
|
|
{
|
|
// Enable or disable the Other sections edit box based on the new state of
|
|
// the Other check box.
|
|
|
|
UpdateData(TRUE) ;
|
|
GetDlgItem(IDC_OtherBox)->EnableWindow(m_bOther) ;
|
|
|
|
// If the Other check box was just checked, move the focus to the Other box.
|
|
|
|
if (m_bOther)
|
|
GetDlgItem(IDC_OtherBox)->SetFocus() ;
|
|
}
|
|
|
|
|
|
void CINFWizInstallSections::BiDiDataChanged()
|
|
{
|
|
// Do nothing if this page has not be initialized yet. In addition, do
|
|
// nothing if the selected models may have changed or a reinit has been
|
|
// request. These cases are taken care of in OnSetActive(). In additon,
|
|
// it allows this routine to know that the model data in this page are in
|
|
// the same order as the data in the BiDi page().
|
|
|
|
if (!m_bInitialized || m_bReInitWData || m_bSelChanged)
|
|
return ;
|
|
|
|
// Loop through the data for each selected model and make sure it agrees
|
|
// as much as possible with the current BiDi settings.
|
|
|
|
CUIntArray* pcuia ;
|
|
for (int n = 0 ; n < m_coaStdInstSecs.GetSize() ; n++) {
|
|
pcuia = (CUIntArray*) m_coaStdInstSecs[n] ;
|
|
|
|
// If the model's BiDi flag is set, make sure it is set here and that
|
|
// its Unidriv and PScript flags are clear.
|
|
|
|
if (m_pciwParent->m_ciwbd.m_cuaBiDiFlags[n]) {
|
|
(*pcuia)[ISF_UNIBIDI] = 1 ;
|
|
(*pcuia)[ISF_UNI] = (*pcuia)[ISF_PSCR] = 0 ;
|
|
|
|
// Otherwise, clear the BiDi flag. Then set the Unidrv flag if the
|
|
// PScript flag is clear.
|
|
|
|
} else {
|
|
(*pcuia)[ISF_UNIBIDI] = 0 ;
|
|
if ((*pcuia)[ISF_PSCR] == 0)
|
|
(*pcuia)[ISF_UNI] = 1 ;
|
|
} ;
|
|
} ;
|
|
|
|
// Reinitialize the controls on the page.
|
|
|
|
InitPageControls() ;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// CINFWizDataSections property page
|
|
|
|
IMPLEMENT_DYNCREATE(CINFWizDataSections, CPropertyPage)
|
|
|
|
CINFWizDataSections::CINFWizDataSections() : CPropertyPage(CINFWizDataSections::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CINFWizDataSections)
|
|
m_csOtherSections = _T("");
|
|
m_bOther = FALSE;
|
|
m_bPscript = FALSE;
|
|
m_bUnidrvBidi = FALSE;
|
|
m_bUnidrv = FALSE;
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bInitialized = m_bReInitWData = m_bSelChanged = false ;
|
|
m_nCurModelIdx = -1 ;
|
|
}
|
|
|
|
|
|
CINFWizDataSections::~CINFWizDataSections()
|
|
{
|
|
// Delete the flag arrays referenced in m_coaStdDataSecs.
|
|
|
|
CUIntArray* pcuia ;
|
|
for (int n = 0 ; n < m_coaStdDataSecs.GetSize() ; n++) {
|
|
pcuia = (CUIntArray*) m_coaStdDataSecs[n] ;
|
|
delete pcuia ;
|
|
} ;
|
|
}
|
|
|
|
|
|
void CINFWizDataSections::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPage::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CINFWizDataSections)
|
|
DDX_Control(pDX, IDC_ModelsLst, m_clbModels);
|
|
DDX_Text(pDX, IDC_OtherBox, m_csOtherSections);
|
|
DDX_Check(pDX, IDC_OtherChk, m_bOther);
|
|
DDX_Check(pDX, IDC_PscriptChk, m_bPscript);
|
|
DDX_Check(pDX, IDC_UnidrvBidiChk, m_bUnidrvBidi);
|
|
DDX_Check(pDX, IDC_UnidrvChk, m_bUnidrv);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFWizDataSections, CPropertyPage)
|
|
//{{AFX_MSG_MAP(CINFWizDataSections)
|
|
ON_LBN_SELCHANGE(IDC_ModelsLst, OnSelchangeModelsLst)
|
|
ON_BN_CLICKED(IDC_OtherChk, OnOtherChk)
|
|
ON_BN_CLICKED(IDC_PscriptChk, OnPscriptChk)
|
|
ON_BN_CLICKED(IDC_UnidrvBidiChk, OnUnidrvBidiChk)
|
|
ON_BN_CLICKED(IDC_UnidrvChk, OnUnidrvChk)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizDataSections message handlers
|
|
|
|
BOOL CINFWizDataSections::OnSetActive()
|
|
{
|
|
// Just perform the default actions if nothing special needs to be done.
|
|
|
|
if (m_bInitialized && (!m_bReInitWData) && (!m_bSelChanged))
|
|
return CPropertyPage::OnSetActive() ;
|
|
|
|
int n, n2 ; // Looping variable
|
|
int numelts, newnumelts ; // Number of elements in an array
|
|
CUIntArray* pcuia ; // Used to reference a model's flags array
|
|
|
|
// Perform the first time initialization.
|
|
|
|
if (!m_bInitialized) {
|
|
// Get a copy of the currently selected model names and initialize the
|
|
// controls on this page.
|
|
|
|
m_csaModels.Copy(m_pciwParent->GetINFModels()) ;
|
|
numelts = InitPageControls() ;
|
|
|
|
// Size and initialize the standard data sections array. There is
|
|
// one entry in the array per model. Each entry references an array
|
|
// of flags that specify the data sections for each model. See
|
|
// below to see how the flags are initialized.
|
|
//
|
|
// The other data sections string array is sized and initialized too.
|
|
|
|
m_coaStdDataSecs.SetSize(numelts) ;
|
|
m_csaOtherDataSecs.SetSize(numelts) ;
|
|
for (n = 0 ; n < numelts ; n++)
|
|
AddModelFlags(n) ;
|
|
|
|
// Set init flag, reset other flags, and return whatever the base class
|
|
// function returns.
|
|
|
|
m_bInitialized = true ;
|
|
m_bReInitWData = m_bSelChanged = false ;
|
|
return CPropertyPage::OnSetActive() ;
|
|
} ;
|
|
|
|
// Either the selected models have changed or the wizard is being
|
|
// reinitialized if this point is reached. Both are handled the same way.
|
|
//
|
|
// Begin by getting info about the models in this page and the ones that
|
|
// are selected now.
|
|
|
|
CStringArray& csanewmodels = m_pciwParent->GetINFModels() ;
|
|
CUIntArray cuiaoldmodelsfound, cuianewmodelsfound ;
|
|
numelts = IdentifyOldAndNewModels(csanewmodels, cuiaoldmodelsfound,
|
|
cuianewmodelsfound, newnumelts,
|
|
m_csaModels) ;
|
|
|
|
// Remove the old models and related data that are no longer needed.
|
|
|
|
for (n = numelts - 1 ; n >= 0 ; n--)
|
|
if (cuiaoldmodelsfound[n] == 0) {
|
|
m_csaModels.RemoveAt(n) ;
|
|
pcuia = (CUIntArray*) m_coaStdDataSecs[n] ;
|
|
delete pcuia ;
|
|
m_coaStdDataSecs.RemoveAt(n) ;
|
|
m_csaOtherDataSecs.RemoveAt(n) ;
|
|
} ;
|
|
|
|
// Add the truly new models to this page's array of model names and
|
|
// initialize all related Data Section data for it.
|
|
|
|
for (n = n2 = 0 ; n < newnumelts ; n++) {
|
|
if (cuianewmodelsfound[n] == 1) {
|
|
n2++ ;
|
|
continue ;
|
|
} ;
|
|
m_csaModels.InsertAt(n2, csanewmodels[n]) ;
|
|
m_coaStdDataSecs.InsertAt(n2, (CObject*) NULL) ;
|
|
m_csaOtherDataSecs.InsertAt(n2, csEmpty) ;
|
|
AddModelFlags(n2) ;
|
|
} ;
|
|
|
|
// Initialize the controls on the page
|
|
|
|
InitPageControls() ;
|
|
|
|
// Set init flag, reset other flags, and return whatever the base class
|
|
// function returns.
|
|
|
|
m_bInitialized = true ;
|
|
m_bReInitWData = m_bSelChanged = false ;
|
|
return CPropertyPage::OnSetActive() ;
|
|
}
|
|
|
|
|
|
void CINFWizDataSections::AddModelFlags(int nidx)
|
|
{
|
|
int n ; // Looping variable
|
|
CUIntArray* pcuia ; // Used to reference a model's flags array
|
|
CString csfname ; // Model's file name
|
|
|
|
// Allocate the flags array and save it in the array of flags arrays.
|
|
// Next, initialize the other sections string for this model.
|
|
|
|
pcuia = new CUIntArray ;
|
|
m_coaStdDataSecs[nidx] = (CObArray*) pcuia ;
|
|
m_csaOtherDataSecs[nidx].Empty() ;
|
|
|
|
// Size the current flags array and initialize each one to 0 (off).
|
|
|
|
pcuia->SetSize(NUMDATASECFLAGS) ;
|
|
for (n = 0 ; n < NUMDATASECFLAGS ; n++)
|
|
(*pcuia)[n] = 0 ;
|
|
|
|
// Get the model's file name and check its extension to see if
|
|
// one of its Unidrv or its PostScript flag should be set. (The
|
|
// other flags are only user settable so they aren't changed.)
|
|
|
|
csfname = m_pciwParent->GetModelFile(m_csaModels[nidx]) ;
|
|
if (csfname.Find(_T(".GPD")) != -1) {
|
|
// The UNIDRVBIDI section is used (flagged) if the user marked
|
|
// this model BIDI. Otherwise, the UNIDRV section is used.
|
|
|
|
if (m_pciwParent->m_ciwbd.m_cuaBiDiFlags[nidx])
|
|
(*pcuia)[IDF_UNIBIDI] = 1 ;
|
|
else
|
|
(*pcuia)[IDF_UNI] = 1 ;
|
|
|
|
// Postcript file.
|
|
|
|
} else
|
|
(*pcuia)[IDF_PSCR] = 1 ;
|
|
}
|
|
|
|
|
|
int CINFWizDataSections::InitPageControls()
|
|
{
|
|
int n ; // Looping variable
|
|
int numelts ; // Number of elements in an array
|
|
|
|
// Load the current set of models into the list box
|
|
|
|
m_clbModels.ResetContent() ;
|
|
for (n = 0, numelts = (int) m_csaModels.GetSize() ; n < numelts ; n++)
|
|
m_clbModels.AddString(m_csaModels[n]) ;
|
|
|
|
// Make sure there is no model selected in the list box and that the box
|
|
// has the focus.
|
|
|
|
m_clbModels.SetCurSel(-1) ;
|
|
m_clbModels.SetFocus() ;
|
|
m_nCurModelIdx = -1 ;
|
|
|
|
// Clear and disable all of the check boxes and the Other edit box.
|
|
|
|
for (n = IDC_UnidrvChk ; n <= IDC_OtherChk ; n++)
|
|
GetDlgItem(n)->EnableWindow(FALSE) ;
|
|
GetDlgItem(IDC_OtherBox)->EnableWindow(FALSE) ;
|
|
m_bUnidrv = m_bUnidrvBidi = m_bPscript = m_bOther = FALSE ;
|
|
m_csOtherSections = csEmpty ;
|
|
UpdateData(FALSE) ;
|
|
|
|
// Return the number of elements in the list box. Ie, the number of
|
|
// selected models.
|
|
|
|
return numelts ;
|
|
}
|
|
|
|
|
|
LRESULT CINFWizDataSections::OnWizardNext()
|
|
{
|
|
// Save the index for the currently selected model. If the value is valid,
|
|
// save the install section data for this model.
|
|
|
|
if ((m_nCurModelIdx = m_clbModels.GetCurSel()) != -1) {
|
|
UpdateData(TRUE) ;
|
|
CUIntArray* pcuia = (CUIntArray*) m_coaStdDataSecs[m_nCurModelIdx] ;
|
|
(*pcuia)[IDF_UNI] = (unsigned) m_bUnidrv ;
|
|
(*pcuia)[IDF_UNIBIDI] = (unsigned) m_bUnidrvBidi ;
|
|
(*pcuia)[IDF_PSCR] = (unsigned) m_bPscript ;
|
|
if ((*pcuia)[IDF_OTHER] = (unsigned) m_bOther)
|
|
m_csaOtherDataSecs[m_nCurModelIdx] = m_csOtherSections ;
|
|
} ;
|
|
|
|
// Make sure that each model has one of the main sections selected and, if
|
|
// the Other section was selected, it has an Other string.
|
|
|
|
CString cserrmsg ;
|
|
CUIntArray* pcuia ;
|
|
int numelts = (int) m_csaModels.GetSize() ;
|
|
for (int n = 0 ; n < numelts ; n++) {
|
|
pcuia = (CUIntArray*) m_coaStdDataSecs[n] ;
|
|
TRACE("*** %s: IDF_UNI=%d IDF_UNIBIDI=%d IDF_PSCR=%d IDF_OTHER=%d\n", m_csaModels[n], (*pcuia)[IDF_UNI], (*pcuia)[IDF_UNIBIDI], (*pcuia)[IDF_PSCR], (*pcuia)[IDF_OTHER]) ;
|
|
if ((*pcuia)[IDF_UNI] == 0 && (*pcuia)[IDF_UNIBIDI] == 0
|
|
&& (*pcuia)[IDF_PSCR] == 0 && (*pcuia)[IDF_OTHER] == 0) {
|
|
cserrmsg.Format(IDS_INFMissingDataSecError, m_csaModels[n]) ;
|
|
AfxMessageBox(cserrmsg, MB_ICONEXCLAMATION) ;
|
|
m_clbModels.SetCurSel(n) ;
|
|
OnSelchangeModelsLst() ;
|
|
return -1 ;
|
|
} ;
|
|
if ((*pcuia)[IDF_OTHER] && m_csaOtherDataSecs[n].IsEmpty()) {
|
|
cserrmsg.Format(IDS_INFNoOtherStrError, m_csaModels[n]) ;
|
|
AfxMessageBox(cserrmsg, MB_ICONEXCLAMATION) ;
|
|
m_clbModels.SetCurSel(n) ;
|
|
OnSelchangeModelsLst() ;
|
|
return -1 ;
|
|
} ;
|
|
} ;
|
|
|
|
// All went well so...
|
|
|
|
return CPropertyPage::OnWizardNext();
|
|
}
|
|
|
|
|
|
LRESULT CINFWizDataSections::OnWizardBack()
|
|
{
|
|
// This works because the same thing needs to be done for both
|
|
// OnWizardNext() and OnWizardBack(). In addition,
|
|
// CPropertyPage::OnWizardNext() and CPropertyPage::OnWizardBack() just
|
|
// return 0.
|
|
|
|
return OnWizardNext() ;
|
|
}
|
|
|
|
|
|
void CINFWizDataSections::OnSelchangeModelsLst()
|
|
{
|
|
// If there was a previous model selection, save its data section flags.
|
|
// Otherwise, enable the install section check boxes.
|
|
|
|
if (m_nCurModelIdx != -1) {
|
|
UpdateData(TRUE) ;
|
|
CUIntArray* pcuia = (CUIntArray*) m_coaStdDataSecs[m_nCurModelIdx] ;
|
|
(*pcuia)[IDF_UNI] = (unsigned) m_bUnidrv ;
|
|
(*pcuia)[IDF_UNIBIDI] = (unsigned) m_bUnidrvBidi ;
|
|
(*pcuia)[IDF_PSCR] = (unsigned) m_bPscript ;
|
|
if ((*pcuia)[IDF_OTHER] = (unsigned) m_bOther)
|
|
m_csaOtherDataSecs[m_nCurModelIdx] = m_csOtherSections ;
|
|
} else {
|
|
for (int n = IDC_UnidrvChk ; n <= IDC_OtherChk ; n++)
|
|
GetDlgItem(n)->EnableWindow(TRUE) ;
|
|
} ;
|
|
|
|
// Save the index for the currently selected model. Then set the check
|
|
// boxes based on the flags for the specified model.
|
|
|
|
m_nCurModelIdx = m_clbModels.GetCurSel() ;
|
|
CUIntArray* pcuia = (CUIntArray*) m_coaStdDataSecs[m_nCurModelIdx] ;
|
|
m_bUnidrv = (BOOL) ((*pcuia)[IDF_UNI]) ;
|
|
m_bUnidrvBidi = (BOOL) ((*pcuia)[IDF_UNIBIDI]) ;
|
|
m_bPscript = (BOOL) ((*pcuia)[IDF_PSCR]) ;
|
|
if (m_bOther = (BOOL) ((*pcuia)[IDF_OTHER]))
|
|
m_csOtherSections = m_csaOtherDataSecs[m_nCurModelIdx] ;
|
|
else
|
|
m_csOtherSections = csEmpty ;
|
|
GetDlgItem(IDC_OtherBox)->EnableWindow(m_bOther) ;
|
|
UpdateData(FALSE) ;
|
|
}
|
|
|
|
|
|
void CINFWizDataSections::OnOtherChk()
|
|
{
|
|
// Enable or disable the Other sections edit box based on the new state of
|
|
// the Other check box.
|
|
|
|
UpdateData(TRUE) ;
|
|
GetDlgItem(IDC_OtherBox)->EnableWindow(m_bOther) ;
|
|
|
|
// If the Other check box was just checked, move the focus to the Other box.
|
|
|
|
if (m_bOther)
|
|
GetDlgItem(IDC_OtherBox)->SetFocus() ;
|
|
}
|
|
|
|
|
|
void CINFWizDataSections::OnPscriptChk()
|
|
{
|
|
// If the PostScript checkbox is checked, the Unidrv boxes must be
|
|
// unchecked.
|
|
|
|
UpdateData(TRUE) ;
|
|
if (m_bPscript) {
|
|
m_bUnidrvBidi = m_bUnidrv = FALSE ;
|
|
UpdateData(FALSE) ;
|
|
}
|
|
}
|
|
|
|
|
|
void CINFWizDataSections::OnUnidrvBidiChk()
|
|
{
|
|
// If the UNIDRV_BIDI box is checked, the UNIDRV and PostScript flags must
|
|
// be unchecked.
|
|
|
|
UpdateData(TRUE) ;
|
|
if (m_bUnidrvBidi) {
|
|
m_bPscript = m_bUnidrv = FALSE ;
|
|
UpdateData(FALSE) ;
|
|
}
|
|
}
|
|
|
|
|
|
void CINFWizDataSections::OnUnidrvChk()
|
|
{
|
|
// If the UNIDRV box is checked, the UNIDRV_BIDI and PostScript flags must
|
|
// be unchecked.
|
|
|
|
UpdateData(TRUE) ;
|
|
if (m_bUnidrv) {
|
|
m_bPscript = m_bUnidrvBidi = FALSE ;
|
|
UpdateData(FALSE) ;
|
|
}
|
|
}
|
|
|
|
|
|
void CINFWizDataSections::BiDiDataChanged()
|
|
{
|
|
// Do nothing if this page has not be initialized yet. In addition, do
|
|
// nothing if the selected models may have changed or a reinit has been
|
|
// request. These cases are taken care of in OnSetActive(). In additon,
|
|
// it allows this routine to know that the model data in this page are in
|
|
// the same order as the data in the BiDi page().
|
|
|
|
if (!m_bInitialized || m_bReInitWData || m_bSelChanged)
|
|
return ;
|
|
|
|
// Loop through the data for each selected model and make sure it agrees
|
|
// as much as possible with the current BiDi settings.
|
|
|
|
CUIntArray* pcuia ;
|
|
for (int n = 0 ; n < m_coaStdDataSecs.GetSize() ; n++) {
|
|
pcuia = (CUIntArray*) m_coaStdDataSecs[n] ;
|
|
|
|
// If the model's BiDi flag is set, make sure it is set here and that
|
|
// its Unidriv and PScript flags are clear.
|
|
|
|
if (m_pciwParent->m_ciwbd.m_cuaBiDiFlags[n]) {
|
|
(*pcuia)[IDF_UNIBIDI] = 1 ;
|
|
(*pcuia)[IDF_UNI] = (*pcuia)[IDF_PSCR] = 0 ;
|
|
|
|
// Otherwise, clear the BiDi flag. Then set the Unidrv flag if the
|
|
// PScript flag is clear.
|
|
|
|
} else {
|
|
(*pcuia)[IDF_UNIBIDI] = 0 ;
|
|
if ((*pcuia)[IDF_PSCR] == 0)
|
|
(*pcuia)[IDF_UNI] = 1 ;
|
|
} ;
|
|
} ;
|
|
|
|
// Reinitialize the controls on the page.
|
|
|
|
InitPageControls() ;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizExtraFiles property page
|
|
|
|
IMPLEMENT_DYNCREATE(CINFWizExtraFiles, CPropertyPage)
|
|
|
|
CINFWizExtraFiles::CINFWizExtraFiles() : CPropertyPage(CINFWizExtraFiles::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CINFWizExtraFiles)
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bInitialized = m_bReInitWData = m_bSelChanged = false ;
|
|
m_nCurModelIdx = -1 ;
|
|
}
|
|
|
|
CINFWizExtraFiles::~CINFWizExtraFiles()
|
|
{
|
|
// Delete the string arrays referenced in m_coaExtraFSArrays.
|
|
|
|
CStringArray* pcsa ;
|
|
for (int n = 0 ; n < m_coaExtraFSArrays.GetSize() ; n++) {
|
|
pcsa = (CStringArray*) m_coaExtraFSArrays[n] ;
|
|
delete pcsa ;
|
|
} ;
|
|
}
|
|
|
|
void CINFWizExtraFiles::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPage::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CINFWizExtraFiles)
|
|
DDX_Control(pDX, IDC_ExtraFSpecsLst, m_cfelcFSpecsLst);
|
|
DDX_Control(pDX, IDC_ModelLst, m_clbModels);
|
|
DDX_Control(pDX, IDC_BrowsBtn, m_cbBrowse);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
void CINFWizExtraFiles::ModelChangeFixups(unsigned unummodelssel,
|
|
CStringArray& csamodels,
|
|
CStringArray& csamodelslast)
|
|
{
|
|
// Do nothing if the page has not been initialized yet.
|
|
|
|
if (!m_bInitialized)
|
|
return ;
|
|
|
|
// See ModelChangeFixupsListListPage() for more information.
|
|
|
|
ModelChangeFixupsListListPage(unummodelssel, csamodels, csamodelslast,
|
|
m_cfelcFSpecsLst, m_coaExtraFSArrays,
|
|
m_nCurModelIdx, &m_cbBrowse, m_clbModels,
|
|
m_bReInitWData) ;
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFWizExtraFiles, CPropertyPage)
|
|
//{{AFX_MSG_MAP(CINFWizExtraFiles)
|
|
ON_LBN_SELCHANGE(IDC_ModelLst, OnSelchangeModelLst)
|
|
ON_BN_CLICKED(IDC_BrowsBtn, OnBrowsBtn)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizExtraFiles message handlers
|
|
|
|
BOOL CINFWizExtraFiles::OnSetActive()
|
|
{
|
|
// Get the list of models to load into the main list box.
|
|
|
|
CStringArray& csamodels = m_pciwParent->GetINFModels() ;
|
|
|
|
// Nothing else need be done if this page has been initialized already
|
|
// and it is not being asked to reinitialize the page... That is,
|
|
// except for possibly needing to pick up any selected model changes
|
|
// that were made.
|
|
|
|
if (m_bInitialized && !m_bReInitWData) {
|
|
if (m_bSelChanged) {
|
|
ModelChangeFixups(m_pciwParent->GetINFModsSelCount(), csamodels,
|
|
m_pciwParent->GetINFModelsLst()) ;
|
|
m_bSelChanged = false ;
|
|
} ;
|
|
return CPropertyPage::OnSetActive() ;
|
|
} ;
|
|
|
|
// Pick up selected model changes when reinitializing
|
|
|
|
if (m_bReInitWData) {
|
|
ModelChangeFixups(m_pciwParent->GetINFModsSelCount(), csamodels,
|
|
m_pciwParent->GetINFModelsLst()) ;
|
|
m_bSelChanged = false ;
|
|
} ;
|
|
|
|
// See InitListListPage() for more details.
|
|
|
|
InitListListPage(m_clbModels, m_bInitialized, m_pciwParent,
|
|
m_coaExtraFSArrays, m_cfelcFSpecsLst,
|
|
IDS_INFExFilesColLab, csamodels, m_bReInitWData,
|
|
m_nCurModelIdx, 256, 0) ;
|
|
return CPropertyPage::OnSetActive() ;
|
|
}
|
|
|
|
|
|
void CINFWizExtraFiles::OnSelchangeModelLst()
|
|
{
|
|
SelChangedListListPage(m_clbModels, m_bInitialized, m_coaExtraFSArrays,
|
|
m_cfelcFSpecsLst, &m_cbBrowse, m_nCurModelIdx) ;
|
|
}
|
|
|
|
|
|
void CINFWizExtraFiles::OnBrowsBtn()
|
|
{
|
|
// See OnBrowseListListPage() for more information.
|
|
|
|
OnBrowseListListPage(m_cfelcFSpecsLst, IDS_CommonExtraFile) ;
|
|
}
|
|
|
|
|
|
LRESULT CINFWizExtraFiles::OnWizardNext()
|
|
{
|
|
// Do nothing if the page has not been initialized yet.
|
|
|
|
if (!m_bInitialized)
|
|
return -1 ;
|
|
|
|
// See OnWizNextListListPage() for more information.
|
|
|
|
OnWizNextListListPage(m_nCurModelIdx, m_cfelcFSpecsLst, m_coaExtraFSArrays);
|
|
return CPropertyPage::OnWizardNext() ;
|
|
}
|
|
|
|
|
|
LRESULT CINFWizExtraFiles::OnWizardBack()
|
|
{
|
|
// This works because the same thing needs to be done for both
|
|
// OnWizardNext() and OnWizardBack(). In addition,
|
|
// CPropertyPage::OnWizardNext() and CPropertyPage::OnWizardBack() just
|
|
// return 0.
|
|
|
|
return OnWizardNext() ;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizMfgName property page
|
|
|
|
IMPLEMENT_DYNCREATE(CINFWizMfgName, CPropertyPage)
|
|
|
|
CINFWizMfgName::CINFWizMfgName() : CPropertyPage(CINFWizMfgName::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CINFWizMfgName)
|
|
m_csMfgName = csEmpty;
|
|
m_csMfgAbbrev = csEmpty;
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bInitialized = m_bReInitWData = false ;
|
|
}
|
|
|
|
|
|
CINFWizMfgName::~CINFWizMfgName()
|
|
{
|
|
}
|
|
|
|
|
|
void CINFWizMfgName::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPage::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CINFWizMfgName)
|
|
DDX_Control(pDX, IDC_ProviderBox, m_ceMfgAbbrev);
|
|
DDX_Control(pDX, IDC_ManufacturerBox, m_ceMfgName);
|
|
DDX_Text(pDX, IDC_ManufacturerBox, m_csMfgName);
|
|
DDV_MaxChars(pDX, m_csMfgName, 64);
|
|
DDX_Text(pDX, IDC_ProviderBox, m_csMfgAbbrev);
|
|
DDV_MaxChars(pDX, m_csMfgAbbrev, 2);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFWizMfgName, CPropertyPage)
|
|
//{{AFX_MSG_MAP(CINFWizMfgName)
|
|
// NOTE: the ClassWizard will add message map macros here
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizMfgName message handlers
|
|
|
|
BOOL CINFWizMfgName::OnSetActive()
|
|
{
|
|
// Do nothing if the page has been initialized already and it is not being
|
|
// asked to reinitialize itself.
|
|
CStringArray csagpd ; // RAID 0001 ; move to head from body
|
|
if (m_bInitialized && !m_bReInitWData)
|
|
return CPropertyPage::OnSetActive() ;
|
|
|
|
// Most of the work needed to initialize this page is only needed when it
|
|
// is NOT being asked to REinitialized itself.
|
|
|
|
if (!m_bReInitWData) {
|
|
// Find the class instance associated with the first selected model.
|
|
|
|
CStringArray& csamodels = m_pciwParent->GetINFModels() ;
|
|
unsigned unummodels = m_pciwParent->GetModelCount() ;
|
|
if(!m_pciwParent->m_pcgc){ //RAID 0001
|
|
for (unsigned u = 0 ; u < unummodels ; u++) {
|
|
if (csamodels[0] == m_pciwParent->GetModel(u).Name())
|
|
break ;
|
|
} ;
|
|
ASSERT(u < unummodels) ;
|
|
LoadFile(m_pciwParent->GetModel(u).FileName(), csagpd) ;
|
|
}
|
|
else
|
|
LoadFile(m_pciwParent->m_pcgc->GetPathName(), csagpd) ;
|
|
//END RAID 0001
|
|
// Open/Read/Close the model's GPD file.
|
|
|
|
|
|
|
|
|
|
// Scan the file for and isolate the ModelName entry.
|
|
|
|
int numlines = (int)csagpd.GetSize() ;
|
|
CString csmodelname(_T("ModelName")) ;
|
|
CString cscurline ;
|
|
int nloc ;
|
|
for (int n = 0 ; n < numlines ; n++) {
|
|
if ((nloc = csagpd[n].Find(csmodelname)) >= 0) {
|
|
csmodelname = csagpd[n].Mid(csmodelname.GetLength() + nloc) ;
|
|
if ((nloc = csmodelname.Find(_T('"'))) >= 0) {
|
|
csmodelname = csmodelname.Mid(nloc + 1) ;
|
|
if ((nloc = csmodelname.Find(_T('"'))) >= 0)
|
|
csmodelname = csmodelname.Left(nloc) ;
|
|
} else {
|
|
if (csmodelname[0] == _T(':'))
|
|
csmodelname = csmodelname.Mid(1) ;
|
|
} ;
|
|
csmodelname.TrimLeft() ;
|
|
csmodelname.TrimRight() ;
|
|
break ;
|
|
} ;
|
|
} ;
|
|
|
|
// If the ModelName entry was found...
|
|
|
|
if (n < numlines && !csmodelname.IsEmpty()) {
|
|
// Use the first space terminated value in the ModelName entry for
|
|
// the manufacturer's name.
|
|
|
|
if ((nloc = csmodelname.Find(_T(' '))) >= 0)
|
|
m_csMfgName = csmodelname.Left(nloc) ;
|
|
else
|
|
m_csMfgName = csmodelname ;
|
|
|
|
// Use the first two letters of the ModelName entry for the
|
|
// provider's "name".
|
|
|
|
m_csMfgAbbrev = csmodelname.Left(2) ;
|
|
m_csMfgAbbrev.MakeUpper() ;
|
|
|
|
// Load the manufacturer and provider names into the edit boxes on
|
|
// this page.
|
|
|
|
UpdateData(false) ;
|
|
} ;
|
|
|
|
// When reinitializing, the member variables associated with the controls
|
|
// are already set so just use them.
|
|
|
|
} else
|
|
UpdateData(false) ;
|
|
|
|
// Set focus to first control, set initialization flag, and return.
|
|
|
|
m_ceMfgName.SetFocus() ;
|
|
m_bInitialized = true ;
|
|
m_bReInitWData = false ; // Reinit (if needed) is done now on this page
|
|
return CPropertyPage::OnSetActive();
|
|
}
|
|
|
|
|
|
LRESULT CINFWizMfgName::OnWizardNext()
|
|
{
|
|
// Get the values for the manufacturer and provider.
|
|
|
|
UpdateData(true) ;
|
|
|
|
// Complain if either field is blank and do not move on to the next page.
|
|
// Make sure the abbreviation is 2 characters long, too.
|
|
|
|
m_csMfgName.TrimLeft() ;
|
|
m_csMfgName.TrimRight() ;
|
|
m_csMfgAbbrev.TrimLeft() ;
|
|
m_csMfgAbbrev.TrimRight() ;
|
|
CString csmsg ;
|
|
if (m_csMfgName.IsEmpty()) {
|
|
m_ceMfgName.SetFocus() ;
|
|
csmsg.LoadString(IDS_NoMfgError) ;
|
|
AfxMessageBox(csmsg, MB_ICONEXCLAMATION) ;
|
|
return -1 ;
|
|
} ;
|
|
if (m_csMfgAbbrev.IsEmpty() || m_csMfgAbbrev.GetLength() != 2) {
|
|
m_ceMfgAbbrev.SetFocus() ;
|
|
csmsg.LoadString(IDS_NoMfgAbbrevError) ;
|
|
AfxMessageBox(csmsg, MB_ICONEXCLAMATION) ;
|
|
return -1 ;
|
|
} ;
|
|
|
|
// All appears to be well so...
|
|
|
|
return CPropertyPage::OnWizardNext() ;
|
|
}
|
|
|
|
|
|
LRESULT CINFWizMfgName::OnWizardBack()
|
|
{
|
|
// This works because the same thing needs to be done for both
|
|
// OnWizardNext() and OnWizardBack(). In addition,
|
|
// CPropertyPage::OnWizardNext() and CPropertyPage::OnWizardBack() just
|
|
// return 0.
|
|
|
|
return OnWizardNext() ;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizNonStdElts property page
|
|
|
|
IMPLEMENT_DYNCREATE(CINFWizNonStdElts, CPropertyPage)
|
|
|
|
CINFWizNonStdElts::CINFWizNonStdElts() : CPropertyPage(CINFWizNonStdElts::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CINFWizNonStdElts)
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bInitialized = m_bReInitWData = m_bNewSectionAdded = false ;
|
|
m_nCurSectionIdx = -1 ;
|
|
}
|
|
|
|
CINFWizNonStdElts::~CINFWizNonStdElts()
|
|
{
|
|
// Delete the string arrays referenced in m_coaSectionArrays.
|
|
|
|
CStringArray* pcsa ;
|
|
for (int n = 0 ; n < m_coaSectionArrays.GetSize() ; n++) {
|
|
pcsa = (CStringArray*) m_coaSectionArrays[n] ;
|
|
delete pcsa ;
|
|
} ;
|
|
}
|
|
|
|
void CINFWizNonStdElts::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPage::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CINFWizNonStdElts)
|
|
DDX_Control(pDX, IDC_NewSectionBtn, m_ceNewSection);
|
|
DDX_Control(pDX, IDC_KeyValueLst, m_felcKeyValueLst);
|
|
DDX_Control(pDX, IDC_SectionLst, m_clbSections);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFWizNonStdElts, CPropertyPage)
|
|
//{{AFX_MSG_MAP(CINFWizNonStdElts)
|
|
ON_LBN_SELCHANGE(IDC_SectionLst, OnSelchangeSectionLst)
|
|
ON_BN_CLICKED(IDC_NewSectionBtn, OnNewSectionBtn)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizNonStdElts message handlers
|
|
|
|
BOOL CINFWizNonStdElts::OnSetActive()
|
|
{
|
|
// Build an array of valid section names.
|
|
|
|
if (!m_bInitialized) {
|
|
m_csaSections.Add(_T("[ControlFlags]")) ;
|
|
m_csaSections.Add(_T("[DestinationDirs]")) ;
|
|
m_csaSections.Add(_T("[Device]")) ;
|
|
m_csaSections.Add(_T("[Install]")) ;
|
|
m_csaSections.Add(_T("[Manufacturer]")) ;
|
|
m_csaSections.Add(_T("[SourceDisksFiles]")) ;
|
|
m_csaSections.Add(_T("[SourceDisksNames]")) ;
|
|
m_csaSections.Add(_T("[Strings]")) ;
|
|
} ;
|
|
|
|
// See InitListListPage() for more details.
|
|
|
|
InitListListPage(m_clbSections, m_bInitialized, m_pciwParent,
|
|
m_coaSectionArrays, m_felcKeyValueLst, IDS_NonStdColLab,
|
|
m_csaSections, m_bReInitWData, m_nCurSectionIdx, 256, 0) ;
|
|
|
|
m_bNewSectionAdded = false ;
|
|
return CPropertyPage::OnSetActive() ;
|
|
}
|
|
|
|
|
|
void CINFWizNonStdElts::OnSelchangeSectionLst()
|
|
{
|
|
SelChangedListListPage(m_clbSections, m_bInitialized, m_coaSectionArrays,
|
|
m_felcKeyValueLst, NULL, m_nCurSectionIdx) ;
|
|
}
|
|
|
|
|
|
void CINFWizNonStdElts::OnNewSectionBtn()
|
|
{
|
|
// Do nothing if the page has not been initialized yet.
|
|
|
|
if (!m_bInitialized)
|
|
return ;
|
|
|
|
// Prompt the user for a new section name. Return if the user cancels.
|
|
|
|
CNewINFSection cnis ;
|
|
if (cnis.DoModal() == IDCANCEL)
|
|
return ;
|
|
|
|
// Get the new section name and add brackets if necessary.
|
|
|
|
CString csnewsec = cnis.m_csNewSection ;
|
|
csnewsec.TrimLeft() ;
|
|
csnewsec.TrimRight() ;
|
|
if (csnewsec[0] != _T('['))
|
|
csnewsec = csLBrack + csnewsec ;
|
|
if (csnewsec.Right(1) != csRBrack)
|
|
csnewsec += csRBrack ;
|
|
|
|
// Add a new string array to hold the data for the new section.
|
|
|
|
CStringArray* pcsa = new CStringArray ;
|
|
int nelts = m_felcKeyValueLst.GetItemCount() ;
|
|
pcsa->SetSize(nelts) ;
|
|
for (int n = 0 ; n < nelts ; n++)
|
|
pcsa->SetAt(n, csEmpty) ;
|
|
m_coaSectionArrays.Add((CObject*) pcsa) ;
|
|
|
|
// Add the new section to the sections array. Then, add the new section to
|
|
// the sections list box and try to select this item and make it visible.
|
|
|
|
m_csaSections.Add(csnewsec) ;
|
|
int nidx = m_clbSections.AddString(csnewsec) ;
|
|
m_clbSections.SetCurSel(nidx) ;
|
|
OnSelchangeSectionLst() ;
|
|
|
|
// Note that a new section was added during this activation of the page.
|
|
|
|
m_bNewSectionAdded = true ;
|
|
}
|
|
|
|
|
|
LRESULT CINFWizNonStdElts::OnWizardNext()
|
|
{
|
|
// Do nothing if the page has not been initialized yet.
|
|
|
|
if (!m_bInitialized)
|
|
return -1 ;
|
|
|
|
// See OnWizNextListListPage() for more information.
|
|
|
|
OnWizNextListListPage(m_nCurSectionIdx, m_felcKeyValueLst,
|
|
m_coaSectionArrays) ;
|
|
|
|
// Make sure the "section used in INF file flags" array is correctly sized.
|
|
|
|
m_cuaSecUsed.SetSize(m_csaSections.GetSize()) ;
|
|
|
|
// If this is not the first time this page has been used, any changes made
|
|
// could affect the data managed by some of the other pages. Make a call
|
|
// to fixup that data when needed.
|
|
|
|
if (m_bNewSectionAdded)
|
|
m_pciwParent->NonStdSecsChanged() ;
|
|
|
|
return CPropertyPage::OnWizardNext() ;
|
|
}
|
|
|
|
|
|
LRESULT CINFWizNonStdElts::OnWizardBack()
|
|
{
|
|
// This works because the same thing needs to be done for both
|
|
// OnWizardNext() and OnWizardBack(). In addition,
|
|
// CPropertyPage::OnWizardNext() and CPropertyPage::OnWizardBack() just
|
|
// return 0.
|
|
|
|
return OnWizardNext() ;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizNonStdModelSecs property page
|
|
|
|
IMPLEMENT_DYNCREATE(CINFWizNonStdModelSecs, CPropertyPage)
|
|
|
|
CINFWizNonStdModelSecs::CINFWizNonStdModelSecs() : CPropertyPage(CINFWizNonStdModelSecs::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CINFWizNonStdModelSecs)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bInitialized = m_bReInitWData = false ;
|
|
m_nCurSectionIdx = -1 ;
|
|
}
|
|
|
|
|
|
CINFWizNonStdModelSecs::~CINFWizNonStdModelSecs()
|
|
{
|
|
// Delete the string arrays referenced in m_coaModelsNeedingSecs.
|
|
|
|
CStringArray* pcsa ;
|
|
for (int n = 0 ; n < m_coaModelsNeedingSecs.GetSize() ; n++) {
|
|
pcsa = (CStringArray*) m_coaModelsNeedingSecs[n] ;
|
|
delete pcsa ;
|
|
} ;
|
|
}
|
|
|
|
|
|
void CINFWizNonStdModelSecs::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPage::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CINFWizNonStdModelSecs)
|
|
DDX_Control(pDX, IDC_ModelSectionLst, m_cfelcModelsLst);
|
|
DDX_Control(pDX, IDC_SectionLst, m_clbSectionsLst);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFWizNonStdModelSecs, CPropertyPage)
|
|
//{{AFX_MSG_MAP(CINFWizNonStdModelSecs)
|
|
ON_LBN_SELCHANGE(IDC_SectionLst, OnSelchangeSectionLst)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizNonStdModelSecs message handlers
|
|
|
|
BOOL CINFWizNonStdModelSecs::OnSetActive()
|
|
{
|
|
// Turn off the finish button.
|
|
|
|
m_pciwParent->SetWizardButtons(PSWIZB_BACK | PSWIZB_NEXT) ;
|
|
|
|
// Just perform the default actions if nothing special needs to be done.
|
|
|
|
if (m_bInitialized && (!m_bReInitWData) && (!m_bSelChanged))
|
|
return CPropertyPage::OnSetActive() ;
|
|
|
|
int n, n2, n3 ; // Looping variable
|
|
int numelts ; // Number of elements in an array
|
|
CStringArray* pcsa ; // Used to reference a sections models array
|
|
|
|
// Perform the first time initialization.
|
|
|
|
if (!m_bInitialized) {
|
|
// Get a copy of the nonstandard section names and the selected model
|
|
// names.
|
|
|
|
m_csaSections.Copy(m_pciwParent->m_ciwnse.m_csaSections) ;
|
|
m_csaModels.Copy(m_pciwParent->GetINFModels()) ;
|
|
|
|
// The following array is used to manage the models that need each
|
|
// section. Set its size to the same as the number of sections and
|
|
// load its elements with pointers to string arrays. Load the sections
|
|
// list box in the same loop.
|
|
|
|
numelts = (int) m_csaSections.GetSize() ;
|
|
m_coaModelsNeedingSecs.SetSize(numelts) ;
|
|
m_clbSectionsLst.ResetContent() ;
|
|
for (n = 0 ; n < numelts ; n++) {
|
|
pcsa = new CStringArray ;
|
|
pcsa->RemoveAll() ;
|
|
m_coaModelsNeedingSecs[n] = (CObArray*) pcsa ;
|
|
m_clbSectionsLst.AddString(m_csaSections[n]) ;
|
|
} ;
|
|
m_clbSectionsLst.SetFocus() ;
|
|
|
|
// Initialize and load the list control
|
|
|
|
InitModelsListCtl() ;
|
|
|
|
// Set init flag, reset other flags, and return whatever the base class
|
|
// function returns.
|
|
|
|
m_bInitialized = true ;
|
|
m_bReInitWData = m_bSelChanged = false ;
|
|
return CPropertyPage::OnSetActive() ;
|
|
} ;
|
|
|
|
// Either the selected models have changed or the wizard is being
|
|
// reinitialized if this point is reached. They are handled in similar
|
|
// ways.
|
|
//
|
|
// Begin by removing references to models that are no longer selected.
|
|
|
|
m_csaModels.RemoveAll() ;
|
|
m_csaModels.Copy(m_pciwParent->GetINFModels()) ;
|
|
int nummodels = (int) m_csaModels.GetSize() ;
|
|
numelts = (int) m_coaModelsNeedingSecs.GetSize() ;
|
|
for (n = 0 ; n < numelts ; n++) {
|
|
pcsa = (CStringArray*) m_coaModelsNeedingSecs[n] ;
|
|
for (n2 = (int) pcsa->GetSize() - 1 ; n2 >= 0 ; n2--) {
|
|
for (n3 = 0 ; n3 < nummodels ; n3++)
|
|
if ((*pcsa)[n2] == m_csaModels[n3])
|
|
break ;
|
|
if (n3 >= nummodels)
|
|
pcsa->RemoveAt(n2) ;
|
|
} ;
|
|
} ;
|
|
|
|
// Reinitialize the list control if the wizard has been reinitialized.
|
|
// Otherwise, the models may have changed so update that column of the
|
|
// list control.
|
|
|
|
if (m_bReInitWData)
|
|
InitModelsListCtl() ;
|
|
else
|
|
m_cfelcModelsLst.SetColumnData((CObArray*) &m_csaModels, 0) ;
|
|
|
|
// Update the sections information.
|
|
|
|
UpdateSectionData() ;
|
|
|
|
// Set init flag, reset other flags, and return whatever the base class
|
|
// function returns.
|
|
|
|
m_bInitialized = true ;
|
|
m_bReInitWData = m_bSelChanged = false ;
|
|
return CPropertyPage::OnSetActive() ;
|
|
}
|
|
|
|
|
|
void CINFWizNonStdModelSecs::OnSelchangeSectionLst()
|
|
{
|
|
// If there was a previous section selection, save the list of models that
|
|
// need it. Otherwise, enable the models list control.
|
|
|
|
if (m_nCurSectionIdx != -1)
|
|
SaveSectionModelInfo() ;
|
|
else
|
|
m_cfelcModelsLst.EnableWindow(TRUE) ;
|
|
|
|
// Save the index of the newly selected section and then use that index to
|
|
// get the array of selected models for the section.
|
|
|
|
m_nCurSectionIdx = m_clbSectionsLst.GetCurSel() ;
|
|
CStringArray* pcsa ;
|
|
pcsa = (CStringArray*) m_coaModelsNeedingSecs[m_nCurSectionIdx] ;
|
|
|
|
// Declare and size a new array that will be loaded with info on the
|
|
// selected models for the current section. Then load the string displayed
|
|
// in the list control for selected models.
|
|
|
|
CStringArray csaselmods ;
|
|
int numelts = (int) m_csaModels.GetSize() ;
|
|
csaselmods.SetSize(numelts) ;
|
|
CString csselstr ;
|
|
csselstr.LoadString(IDS_INF_NSMS_ToggleStr) ;
|
|
|
|
// Use the list of all models and the current selection's list of models to
|
|
// build an array with the selected string in the right spots so that this
|
|
// array can be loaded into the list control.
|
|
|
|
for (int n2 = 0 ; n2 < pcsa->GetSize() ; n2++)
|
|
for (int n = 0 ; n < numelts ; n++)
|
|
if ((*pcsa)[n2] == m_csaModels[n])
|
|
csaselmods[n] = csselstr ;
|
|
|
|
// Load array built above into the list control so that the user can see
|
|
// which models have been selected for the current section.
|
|
|
|
m_cfelcModelsLst.SetColumnData((CObArray*) &csaselmods, 1) ;
|
|
}
|
|
|
|
|
|
LRESULT CINFWizNonStdModelSecs::OnWizardNext()
|
|
{
|
|
// If there was a previous section selection, save the list of models that
|
|
// need it.
|
|
|
|
if (m_nCurSectionIdx != -1)
|
|
SaveSectionModelInfo() ;
|
|
|
|
return CPropertyPage::OnWizardNext();
|
|
}
|
|
|
|
|
|
LRESULT CINFWizNonStdModelSecs::OnWizardBack()
|
|
{
|
|
// This works because the same thing needs to be done for both
|
|
// OnWizardNext() and OnWizardBack(). In addition,
|
|
// CPropertyPage::OnWizardNext() and CPropertyPage::OnWizardBack() just
|
|
// return 0.
|
|
|
|
return OnWizardNext() ;
|
|
}
|
|
|
|
|
|
void CINFWizNonStdModelSecs::SaveSectionModelInfo()
|
|
{
|
|
// Get the selection data out of the list control.
|
|
|
|
CStringArray csaselmods ;
|
|
m_cfelcModelsLst.GetColumnData((CObArray*) &csaselmods, 1) ;
|
|
|
|
// Use the index of the selected section to get a list of its currently
|
|
// selected models. Remove the models in it because it will be refilled
|
|
// with new data later.
|
|
|
|
CStringArray* pcsa ;
|
|
pcsa = (CStringArray*) m_coaModelsNeedingSecs[m_nCurSectionIdx] ;
|
|
pcsa->RemoveAll() ;
|
|
|
|
// Add every selected model to the section's selected models array.
|
|
|
|
for (int n = 0 ; n < m_csaModels.GetSize() ; n++)
|
|
if (!csaselmods[n].IsEmpty())
|
|
pcsa->Add(m_csaModels[n]) ;
|
|
}
|
|
|
|
|
|
void CINFWizNonStdModelSecs::NonStdSecsChanged()
|
|
{
|
|
// Do nothing if this page has not be initialized yet. In addition, do
|
|
// nothing if the selected models may have changed or a reinit has been
|
|
// request. These cases are taken care of in OnSetActive().
|
|
|
|
if (!m_bInitialized || m_bReInitWData || m_bSelChanged)
|
|
return ;
|
|
|
|
// Update the section data to agree with any changes that may have been
|
|
// made.
|
|
|
|
UpdateSectionData() ;
|
|
}
|
|
|
|
|
|
void CINFWizNonStdModelSecs::UpdateSectionData()
|
|
{
|
|
// Get a copy of the latest nonstandard section.
|
|
|
|
int n, n2 ; // Looping variables
|
|
CStringArray csanewsections ;
|
|
csanewsections.Copy(m_pciwParent->m_ciwnse.m_csaSections) ;
|
|
|
|
// Allocate and size the flags arrays used to determine which sections are
|
|
// still in use.
|
|
|
|
int numelts = (int) m_csaSections.GetSize() ;
|
|
int newnumelts = (int) csanewsections.GetSize() ;
|
|
CUIntArray cuiaoldflags, cuianewflags ;
|
|
cuiaoldflags.SetSize(numelts) ;
|
|
for (n = 0 ; n < numelts ; n++)
|
|
cuiaoldflags[n] = 0 ;
|
|
cuianewflags.SetSize(newnumelts) ;
|
|
for (n = 0 ; n < newnumelts ; n++)
|
|
cuianewflags[n] = 0 ;
|
|
|
|
// Loop through the old & new models to see which of them are still in use.
|
|
|
|
for (n = 0 ; n < numelts ; n++)
|
|
for (n2 = 0 ; n2 < newnumelts ; n2++)
|
|
if (m_csaSections[n] == csanewsections[n2]) {
|
|
cuiaoldflags[n] = cuianewflags[n2] = 1 ;
|
|
break ;
|
|
} ;
|
|
|
|
// Remove the old sections and related data that are no longer needed.
|
|
|
|
CStringArray* pcsa ;
|
|
for (n = numelts - 1 ; n >= 0 ; n--)
|
|
if (cuiaoldflags[n] == 0) {
|
|
m_csaSections.RemoveAt(n) ;
|
|
pcsa = (CStringArray*) m_coaModelsNeedingSecs[n] ;
|
|
delete pcsa ;
|
|
m_coaModelsNeedingSecs.RemoveAt(n) ;
|
|
} ;
|
|
|
|
// Add the truly new sections to this page's array of section names and
|
|
// initialize all related section data for it.
|
|
|
|
for (n = n2 = 0 ; n < newnumelts ; n++) {
|
|
if (cuianewflags[n] == 1) {
|
|
n2++ ;
|
|
continue ;
|
|
} ;
|
|
m_csaSections.InsertAt(n2, csanewsections[n]) ;
|
|
pcsa = new CStringArray ;
|
|
m_coaModelsNeedingSecs.InsertAt(n2, (CObject*) pcsa) ;
|
|
} ;
|
|
|
|
// Clear the sections list box and reload it with the new sections data.
|
|
// Make sure that nothing is selected in the listbox and give it the focus.
|
|
|
|
m_clbSectionsLst.ResetContent() ;
|
|
for (n = 0, numelts = (int) m_csaSections.GetSize() ; n < numelts ; n++)
|
|
m_clbSectionsLst.AddString(m_csaSections[n]) ;
|
|
m_clbSectionsLst.SetCurSel(-1) ;
|
|
m_nCurSectionIdx = -1 ;
|
|
m_clbSectionsLst.SetFocus() ;
|
|
|
|
// Clear the selected models column in the list control and disable it.
|
|
|
|
CStringArray csa ;
|
|
csa.SetSize(m_csaModels.GetSize()) ;
|
|
m_cfelcModelsLst.SetColumnData((CObArray*) &csa, 1) ;
|
|
m_cfelcModelsLst.EnableWindow(FALSE) ;
|
|
}
|
|
|
|
|
|
void CINFWizNonStdModelSecs::InitModelsListCtl()
|
|
{
|
|
int numelts ; // Number of elements in an array
|
|
CString cstmp ;
|
|
|
|
// Initialize the list control
|
|
|
|
numelts = (int) m_csaModels.GetSize() ;
|
|
m_cfelcModelsLst.InitControl(LVS_EX_FULLROWSELECT, numelts, 2,
|
|
TF_HASTOGGLECOLUMNS+TF_CLICKONROW, 0,
|
|
MF_IGNOREINSDEL) ;
|
|
|
|
// Load the models column in the list control.
|
|
|
|
cstmp.LoadString(IDS_INFModelsColLab) ;
|
|
m_cfelcModelsLst.InitLoadColumn(0, cstmp, COMPUTECOLWIDTH, 25, false,
|
|
false, COLDATTYPE_STRING,
|
|
(CObArray*) &m_csaModels) ;
|
|
|
|
// Initialize the bidi column in the list control.
|
|
|
|
cstmp.LoadString(IDS_INFSecNeededColLab) ;
|
|
CStringArray csaempty ;
|
|
m_csToggleStr.LoadString(IDS_INF_NSMS_ToggleStr) ;
|
|
m_cfelcModelsLst.InitLoadColumn(1, cstmp, SETWIDTHTOREMAINDER, -25,
|
|
false, false, COLDATTYPE_TOGGLE,
|
|
(CObArray*) &csaempty, m_csToggleStr) ;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizSummary property page
|
|
|
|
IMPLEMENT_DYNCREATE(CINFWizSummary, CPropertyPage)
|
|
|
|
CINFWizSummary::CINFWizSummary() : CPropertyPage(CINFWizSummary::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CINFWizSummary)
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bInitialized = m_bReInitWData = false ;
|
|
}
|
|
|
|
|
|
CINFWizSummary::~CINFWizSummary()
|
|
{
|
|
}
|
|
|
|
|
|
void CINFWizSummary::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPage::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CINFWizSummary)
|
|
DDX_Control(pDX, IDC_SummaryBox, m_ceSummary);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFWizSummary, CPropertyPage)
|
|
//{{AFX_MSG_MAP(CINFWizSummary)
|
|
// NOTE: the ClassWizard will add message map macros here
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizSummary message handlers
|
|
|
|
BOOL CINFWizSummary::OnSetActive()
|
|
{
|
|
// Turn on the finish button.
|
|
|
|
m_pciwParent->SetWizardButtons(PSWIZB_BACK | PSWIZB_FINISH) ;
|
|
|
|
// Initialize the summary to empty.
|
|
|
|
CString cs, cs2, cs3, cs4, cssummary ;
|
|
cssummary = csEmpty ;
|
|
|
|
// Add the selected models to the summary
|
|
|
|
CStringArray& csamodels = m_pciwParent->GetINFModels() ;
|
|
cssummary.LoadString(IDS_ModelsSumTxt) ;
|
|
int nummodels = (int)csamodels.GetSize() ;
|
|
for (int n = 0 ; n < nummodels ; n++) {
|
|
cs.Format("\t%s\r\n", csamodels[n]) ;
|
|
cssummary += cs ;
|
|
} ;
|
|
|
|
// Add PnP ID info to the summary
|
|
|
|
cs.LoadString(IDS_PnPIDSumTxt) ;
|
|
cssummary += cs ;
|
|
bool bfoundone = false ;
|
|
for (n = 0 ; n < nummodels ; n++) {
|
|
if (!m_pciwParent->m_ciwgpi.m_csaModelIDs[n].IsEmpty()) {
|
|
cs.Format("\t%s: %s\r\n", csamodels[n],
|
|
m_pciwParent->m_ciwgpi.m_csaModelIDs[n]) ;
|
|
cssummary += cs ;
|
|
bfoundone = true ;
|
|
} ;
|
|
} ;
|
|
if (!bfoundone) {
|
|
cs.LoadString(IDS_NoneSumTxt) ;
|
|
cssummary += cs ;
|
|
} ;
|
|
|
|
// Add BIDI info to the summary
|
|
|
|
cs.LoadString(IDS_BIDISumTxt) ;
|
|
cssummary += cs ;
|
|
bfoundone = false ;
|
|
for (n = 0 ; n < nummodels ; n++) {
|
|
if (m_pciwParent->m_ciwbd.m_cuaBiDiFlags[n]) {
|
|
cs.Format("\t%s\r\n", csamodels[n]) ;
|
|
cssummary += cs ;
|
|
bfoundone = true ;
|
|
} ;
|
|
} ;
|
|
if (!bfoundone) {
|
|
cs.LoadString(IDS_NoneSumTxt) ;
|
|
cssummary += cs ;
|
|
} ;
|
|
|
|
// Add the ICM profiles info to the summary.
|
|
|
|
cs.LoadString(IDS_ICMSumTxt) ;
|
|
cssummary += cs ;
|
|
bfoundone = false ;
|
|
CStringArray* pcsa ;
|
|
int n2, numstrs ;
|
|
for (n = 0 ; n < nummodels ; n++) {
|
|
pcsa = (CStringArray*) m_pciwParent->m_ciwip.m_coaProfileArrays[n] ;
|
|
if ((numstrs = (int)pcsa->GetSize()) > 0) {
|
|
cs.Format("\t%s\r\n", csamodels[n]) ;
|
|
cssummary += cs ;
|
|
bfoundone = true ;
|
|
for (n2 = 0 ; n2 < numstrs ; n2++) {
|
|
cs.Format("\t\t%s\r\n", pcsa->GetAt(n2)) ;
|
|
cssummary += cs ;
|
|
} ;
|
|
} ;
|
|
} ;
|
|
if (!bfoundone) {
|
|
cs.LoadString(IDS_NoneSumTxt) ;
|
|
cssummary += cs ;
|
|
} ;
|
|
|
|
// Add the include files info to the summary
|
|
|
|
cs.LoadString(IDS_IncFilesSumTxt) ;
|
|
cssummary += cs ;
|
|
for (n = 0 ; n < nummodels ; n++) {
|
|
cs.Format("\t%s\r\n\t\t%s\r\n", csamodels[n],
|
|
m_pciwParent->m_ciwif.m_csaIncFiles[n]) ;
|
|
cssummary += cs ;
|
|
} ;
|
|
|
|
// Add the install sections info to the summary
|
|
|
|
cs.LoadString(IDS_InstSecsSumTxt) ;
|
|
cssummary += cs ;
|
|
CUIntArray* pcuia ;
|
|
int nid ;
|
|
for (n = 0 ; n < nummodels ; n++) {
|
|
cs.Format("\t%s\r\n", csamodels[n]) ;
|
|
cssummary += cs ;
|
|
pcuia = (CUIntArray*) m_pciwParent->m_ciwis.m_coaStdInstSecs[n] ;
|
|
cs = cs3 = cs4 = csEmpty ;
|
|
cs = "\t\t" ;
|
|
nid = IDS_InstSecUni ;
|
|
for (n2 = 0 ; n2 < NUMINSTSECFLAGS - 1 ; n2++, nid++)
|
|
if ((*pcuia)[n2]) {
|
|
cs2.LoadString(nid) ;
|
|
cs4.Format("%s%s", cs3, cs2) ;
|
|
cs += cs4 ;
|
|
cs3 = _T(", ") ;
|
|
} ;
|
|
if ((*pcuia)[ISF_OTHER]) {
|
|
cs4.Format("%s%s", cs3,
|
|
m_pciwParent->m_ciwis.m_csaOtherInstSecs[n]) ;
|
|
cs += cs4 ;
|
|
} ;
|
|
cssummary += cs + csCRLF ;
|
|
} ;
|
|
|
|
// Add the data sections info to the summary
|
|
|
|
cs.LoadString(IDS_DataSecsSumTxt) ;
|
|
cssummary += cs ;
|
|
for (n = 0 ; n < nummodels ; n++) {
|
|
cs.Format("\t%s\r\n", csamodels[n]) ;
|
|
cssummary += cs ;
|
|
pcuia = (CUIntArray*) m_pciwParent->m_ciwds.m_coaStdDataSecs[n] ;
|
|
cs = cs3 = cs4 = csEmpty ;
|
|
cs = "\t\t" ;
|
|
nid = IDS_DataSecUni ;
|
|
for (n2 = 0 ; n2 < NUMDATASECFLAGS - 1 ; n2++, nid++)
|
|
if ((*pcuia)[n2]) {
|
|
cs2.LoadString(nid) ;
|
|
cs4.Format("%s%s", cs3, cs2) ;
|
|
cs += cs4 ;
|
|
cs3 = _T(", ") ;
|
|
} ;
|
|
if ((*pcuia)[IDF_OTHER]) {
|
|
cs4.Format("%s%s", cs3,
|
|
m_pciwParent->m_ciwds.m_csaOtherDataSecs[n]) ;
|
|
cs += cs4 ;
|
|
} ;
|
|
cssummary += cs + csCRLF ;
|
|
} ;
|
|
|
|
// Add the nonstandard files info to the summary
|
|
|
|
cs.LoadString(IDS_NonStdFilesSumTxt) ;
|
|
cssummary += cs ;
|
|
bfoundone = false ;
|
|
for (n = 0 ; n < nummodels ; n++) {
|
|
pcsa = (CStringArray*) m_pciwParent->m_ciwef.m_coaExtraFSArrays[n] ;
|
|
if ((numstrs = (int)pcsa->GetSize()) > 0) {
|
|
cs.Format("\t%s\r\n", csamodels[n]) ;
|
|
cssummary += cs ;
|
|
bfoundone = true ;
|
|
for (n2 = 0 ; n2 < numstrs ; n2++) {
|
|
cs.Format("\t\t%s\r\n", pcsa->GetAt(n2)) ;
|
|
cssummary += cs ;
|
|
} ;
|
|
} ;
|
|
} ;
|
|
if (!bfoundone) {
|
|
cs.LoadString(IDS_NoneSumTxt) ;
|
|
cssummary += cs ;
|
|
} ;
|
|
|
|
// Add the manufacturer and provider info to the summary
|
|
|
|
cs.Format(IDS_MfgSumTxt, m_pciwParent->m_ciwmn.m_csMfgName) ;
|
|
cssummary += cs ;
|
|
cs.Format(IDS_ProvSumTxt, m_pciwParent->m_ciwmn.m_csMfgAbbrev) ;
|
|
cssummary += cs ;
|
|
|
|
// Add the nonstandard sections info to the summary
|
|
|
|
cs.LoadString(IDS_NonStdSecSumTxt) ;
|
|
cssummary += cs ;
|
|
bfoundone = false ;
|
|
CStringArray& csasections = m_pciwParent->m_ciwnse.m_csaSections ;
|
|
nummodels = (int)csasections.GetSize() ;
|
|
for (n = 0 ; n < nummodels ; n++) {
|
|
pcsa = (CStringArray*) m_pciwParent->m_ciwnse.m_coaSectionArrays[n] ;
|
|
if ((numstrs = (int)pcsa->GetSize()) > 0) {
|
|
cs.Format("\t%s\r\n", csasections[n]) ;
|
|
cssummary += cs ;
|
|
bfoundone = true ;
|
|
for (n2 = 0 ; n2 < numstrs ; n2++) {
|
|
cs.Format("\t\t%s\r\n", pcsa->GetAt(n2)) ;
|
|
cssummary += cs ;
|
|
} ;
|
|
} ;
|
|
} ;
|
|
if (!bfoundone) {
|
|
cs.LoadString(IDS_NoneSumTxt) ;
|
|
cssummary += cs ;
|
|
} ;
|
|
|
|
// Add the nonstandard sections needed by models info to the summary
|
|
|
|
cs.LoadString(IDS_NonStdModelsSumTxt) ;
|
|
cssummary += cs ;
|
|
bfoundone = false ;
|
|
int numsections = (int) m_pciwParent->m_ciwnsms.m_csaSections.GetSize() ;
|
|
for (n = 0 ; n < numsections ; n++) {
|
|
pcsa = (CStringArray*)m_pciwParent->m_ciwnsms.m_coaModelsNeedingSecs[n];
|
|
if ((numstrs = (int)pcsa->GetSize()) > 0) {
|
|
cs.Format("\t%s\r\n", m_pciwParent->m_ciwnsms.m_csaSections[n]) ;
|
|
cssummary += cs ;
|
|
bfoundone = true ;
|
|
for (n2 = 0 ; n2 < numstrs ; n2++) {
|
|
cs.Format("\t\t%s\r\n", pcsa->GetAt(n2)) ;
|
|
cssummary += cs ;
|
|
} ;
|
|
} ;
|
|
} ;
|
|
if (!bfoundone) {
|
|
cs.LoadString(IDS_NoneSumTxt) ;
|
|
cssummary += cs ;
|
|
} ;
|
|
|
|
// Load the edit box, set the initialized flag, and return.
|
|
|
|
m_ceSummary.SetSel(0, -1) ;
|
|
m_ceSummary.ReplaceSel(cssummary) ;
|
|
m_ceSummary.SetSel(0, 0) ;
|
|
m_ceSummary.SetSel(-1, 0) ;
|
|
m_ceSummary.SetReadOnly() ;
|
|
m_bInitialized = true ; // Page is initialized now
|
|
return CPropertyPage::OnSetActive();
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CNewINFSection dialog
|
|
|
|
CNewINFSection::CNewINFSection(CWnd* pParent /*=NULL*/)
|
|
: CDialog(CNewINFSection::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CNewINFSection)
|
|
m_csNewSection = csEmpty;
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
void CNewINFSection::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CNewINFSection)
|
|
DDX_Text(pDX, IDC_NewSectionBox, m_csNewSection);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CNewINFSection, CDialog)
|
|
//{{AFX_MSG_MAP(CNewINFSection)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CNewINFSection message handlers
|
|
|
|
void CNewINFSection::OnOK()
|
|
{
|
|
UpdateData() ;
|
|
|
|
CDialog::OnOK();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizView
|
|
|
|
IMPLEMENT_DYNCREATE(CINFWizView, CEditView)
|
|
|
|
CINFWizView::CINFWizView()
|
|
{
|
|
m_pcicdCheckDoc = NULL ;
|
|
m_pcmcwCheckFrame = NULL ;
|
|
}
|
|
|
|
|
|
CINFWizView::~CINFWizView()
|
|
{
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFWizView, CEditView)
|
|
//{{AFX_MSG_MAP(CINFWizView)
|
|
ON_COMMAND(ID_FILE_Change_INF, OnFILEChangeINF)
|
|
ON_COMMAND(ID_FILE_Check_INF, OnFILECheckINF)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizView drawing
|
|
|
|
void CINFWizView::OnDraw(CDC* pDC)
|
|
{
|
|
CDocument* pDoc = GetDocument();
|
|
// TODO: add draw code here
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizView diagnostics
|
|
|
|
#ifdef _DEBUG
|
|
void CINFWizView::AssertValid() const
|
|
{
|
|
CEditView::AssertValid();
|
|
}
|
|
|
|
void CINFWizView::Dump(CDumpContext& dc) const
|
|
{
|
|
CEditView::Dump(dc);
|
|
}
|
|
#endif //_DEBUG
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizView message handlers
|
|
|
|
void CINFWizView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView)
|
|
{
|
|
// TODO: Add your specialized code here and/or call the base class
|
|
|
|
CEditView::OnActivateView(bActivate, pActivateView, pDeactiveView);
|
|
}
|
|
|
|
|
|
void CINFWizView::OnInitialUpdate()
|
|
{
|
|
// Set the frame's window style and initialize the edit box.
|
|
|
|
GetParentFrame()->ModifyStyle(0, WS_OVERLAPPEDWINDOW) ;
|
|
CEditView::OnInitialUpdate();
|
|
|
|
// Set a default title for the window.
|
|
|
|
CString cs ;
|
|
cs.LoadString(IDS_INFFile) ;
|
|
GetDocument()->SetTitle(cs) ;
|
|
|
|
// Load the edit box with the contents of the INF file.
|
|
|
|
GetEditCtrl().SetSel(0, -1) ;
|
|
GetEditCtrl().ReplaceSel( ((CINFWizDoc*) GetDocument())->m_pciw->m_csINFContents ) ;
|
|
GetEditCtrl().SetSel(0, 0) ;
|
|
GetEditCtrl().SetSel(-1, 0) ;
|
|
// GetEditCtrl().SetReadOnly() ;
|
|
}
|
|
|
|
|
|
void CINFWizView::OnFILEChangeINF()
|
|
{
|
|
// Restart the wizard so that the users changes can be collected.
|
|
|
|
CINFWizDoc* pciwd = (CINFWizDoc*) GetDocument() ;
|
|
CINFWizard* pciw = pciwd->m_pciw ;
|
|
pciw->PrepareToRestart() ;
|
|
if (pciw->DoModal() == IDCANCEL)
|
|
return ;
|
|
|
|
// Regenerate the INF contents
|
|
|
|
if (!pciw->GenerateINFFile())
|
|
return ;
|
|
|
|
// Load the edit box with the contents of the new INF.
|
|
|
|
GetEditCtrl().SetSel(0, -1) ;
|
|
GetEditCtrl().ReplaceSel(pciw->m_csINFContents) ;
|
|
GetEditCtrl().SetSel(0, 0) ;
|
|
GetEditCtrl().SetSel(-1, 0) ;
|
|
GetEditCtrl().SetReadOnly() ;
|
|
}
|
|
|
|
|
|
void CINFWizView::OnFILECheckINF()
|
|
{
|
|
// This might take a while, so...
|
|
|
|
CWaitCursor cwc ;
|
|
|
|
// Remove the contents of any existing INF checking window and reset the
|
|
// checking flag.
|
|
|
|
ResetINFErrorWindow() ;
|
|
|
|
// Get a pointer to the wizard class because it contains some functions
|
|
// that will be useful to file checking process.
|
|
|
|
CINFWizDoc* pciwd = (CINFWizDoc*) GetDocument() ;
|
|
CINFWizard* pciw = pciwd->m_pciw ;
|
|
|
|
// Get a reference to the array of selected models and a count of them. Use
|
|
// them to loop through each model. Allocate all of the variables needed
|
|
// for processing including the string to hold the various paths that will
|
|
// be needed.
|
|
|
|
CStringArray& csamodels = pciw->GetINFModels() ;
|
|
int nummodels = (int)csamodels.GetSize() ;
|
|
CString csfspec, cspath, csmodel, cs, cstmp,csprojpath ;
|
|
//RAID 0001
|
|
|
|
if(pciw ->m_pcgc){
|
|
cstmp = pciwd->m_pcgc->GetPathName();
|
|
cstmp = cstmp.Left(cstmp.ReverseFind(csBSlash[0])); //cstmp are used instead GetW2000()
|
|
csprojpath = cstmp.Left(cstmp.ReverseFind(csBSlash[0])+1) ;
|
|
} //END RAID 0001
|
|
else {
|
|
csprojpath = pciwd->m_pcpr->GetProjFSpec() ;
|
|
csprojpath = csprojpath.Left(csprojpath.ReverseFind(csBSlash[0]) + 1) ;
|
|
}
|
|
CFileStatus cfs ;
|
|
int n ;
|
|
BOOL bexists ;
|
|
|
|
// Do all of the checking for each model before moving on to the next one.
|
|
|
|
for (n = 0 ; n < nummodels ; n++) {
|
|
csmodel = csamodels[n] ;
|
|
|
|
// Make sure that the GPD file for the model exists.
|
|
|
|
csfspec = pciw->GetModelFile(csmodel, true) ;
|
|
if (!(bexists = CFile::GetStatus(csfspec, cfs))) {
|
|
cs.Format(IDS_INFChk_NoModErr, csmodel, csfspec) ;
|
|
PostINFCheckingMessage(cs) ;
|
|
} ;
|
|
cspath = csfspec.Left(csfspec.ReverseFind(csBSlash[0]) + 1) ;
|
|
|
|
// Verify the existence of the files referenced in include statements
|
|
// in the current GPD file iff the GPD file exists.
|
|
|
|
if (bexists)
|
|
CheckIncludeFiles(csfspec, cspath, csmodel) ;
|
|
|
|
// Check for the existence of the ICM files (if any) for this GPD.
|
|
|
|
CheckArrayOfFiles((CStringArray*) pciw->m_ciwip.m_coaProfileArrays[n],
|
|
csfspec, cspath, csprojpath, csmodel,
|
|
IDS_INFChk_NoICMFileErr) ;
|
|
|
|
// Check for the existence of the nonstd files (if any) for this GPD.
|
|
|
|
CheckArrayOfFiles((CStringArray*) pciw->m_ciwef.m_coaExtraFSArrays[n],
|
|
csfspec, cspath, csprojpath, csmodel,
|
|
IDS_INFChk_NoNonStdFileErr) ;
|
|
} ;
|
|
|
|
// Check for the existence of the resource DLL. First look for it in the
|
|
// project directory. If it isn't there, try the W2K directory.
|
|
|
|
// RAID 0001
|
|
if(pciw->m_pcgc)
|
|
cs = pciw->m_pcgc->ModelData()->GetKeywordValue(pciw->m_pcgc->GetPathName(),_T("ResourceDLL"));
|
|
else{ //END RAID 0001
|
|
cs = pciwd->m_pcpr->DriverName() ;
|
|
cs = cs.Left(8) + _T(".dll") ; // Resource DLL name.
|
|
}
|
|
if (!CFile::GetStatus(csprojpath + cs, cfs)) {
|
|
cstmp = (pciw->m_pcgc) ? cstmp + csBSlash : pciwd->m_pcpr->GetW2000Path() + csBSlash ; //RAID 0001
|
|
if (!CFile::GetStatus(cstmp + cs, cfs)) {
|
|
cstmp.Format(IDS_INFChk_NoResDLLErr, (pciw->m_pcgc)? cs :
|
|
pciwd->m_pcpr->DriverName(), cs) ; //RAID 0001
|
|
PostINFCheckingMessage(cstmp) ;
|
|
} ;
|
|
} ;
|
|
|
|
// Tell the user if no problems were found.
|
|
|
|
if (!m_bChkingErrsFound)
|
|
AfxMessageBox(IDS_INFChecksOK, MB_ICONINFORMATION) ;
|
|
}
|
|
|
|
|
|
void CINFWizView::CheckArrayOfFiles(CStringArray* pcsa, CString& csfspec,
|
|
CString& cspath, CString& csprojpath,
|
|
CString& csmodel, int nerrid)
|
|
{
|
|
// There is nothing to do if there are no filespecs in the array.
|
|
|
|
int numfiles ;
|
|
if ((numfiles = (int)pcsa->GetSize()) == 0)
|
|
return ;
|
|
|
|
// Variables needed for file existence checking
|
|
|
|
int n ;
|
|
BOOL bexists ;
|
|
CString csfile, csmsg ;
|
|
CFileStatus cfs ;
|
|
|
|
// Check for the existence of each file.
|
|
|
|
for (n = 0 ; n < numfiles ; n++) {
|
|
csfile = pcsa->GetAt(n) ;
|
|
|
|
// If the file string contains a full filespec, just check it.
|
|
|
|
if (csfile[1] == _T(':'))
|
|
bexists = CFile::GetStatus(csfile, cfs) ;
|
|
|
|
// Otherwise, add the GPD path and, if needed, the project path to the
|
|
// file string and check to see if the file is there.
|
|
|
|
else {
|
|
if (!(bexists = CFile::GetStatus(cspath + csfile, cfs)))
|
|
bexists = CFile::GetStatus(csprojpath + csfile, cfs) ;
|
|
} ;
|
|
|
|
// Post a message if the file was not found.
|
|
|
|
if (!bexists) {
|
|
csmsg.Format(nerrid, csmodel, csfile) ;
|
|
PostINFCheckingMessage(csmsg) ;
|
|
} ;
|
|
} ;
|
|
}
|
|
|
|
|
|
void CINFWizView::CheckIncludeFiles(CString& csfspec, CString& cspath,
|
|
CString& csmodel)
|
|
{
|
|
// Variables needed to read the GPD and check include files.
|
|
|
|
CStringArray csagpdfile ;
|
|
CString csinc(_T("*Include:")), cs, cstmp ;
|
|
int n, numstrs, nloc ;
|
|
CFileStatus cfs ;
|
|
|
|
// Include files can only be checked if the GPD file can be read.
|
|
|
|
if (LoadFile(csfspec, csagpdfile)) {
|
|
numstrs = (int)csagpdfile.GetSize() ;
|
|
|
|
// Check each line in the GPD file to see if it contains an include
|
|
// statement.
|
|
|
|
for (n = 0 ; n < numstrs ; n++) {
|
|
// Skip statement if not include statement
|
|
|
|
if ((nloc = csagpdfile[n].Find(csinc)) == -1)
|
|
continue ;
|
|
|
|
// Isolate the filespec in the include statement
|
|
|
|
cs = csagpdfile[n].Mid(nloc + csinc.GetLength()) ;
|
|
cs.TrimLeft() ;
|
|
cs.TrimRight() ;
|
|
if (cs[0] == csQuote[0]) // Remove quotes
|
|
cs = cs.Mid(1, cs.GetLength() - 2) ;
|
|
|
|
// If the include file's filespec is relative, add the GPD's
|
|
// path to it. Then test for the file's existence. Post a
|
|
// message if the file does not exist.
|
|
|
|
if (cs[1] != _T(':'))
|
|
cs = cspath + cs ;
|
|
if (!CFile::GetStatus(cs, cfs)) {
|
|
cstmp.Format(IDS_INFChk_NoIncFileErr, csmodel, cs,
|
|
csfspec) ;
|
|
PostINFCheckingMessage(cstmp) ;
|
|
} ;
|
|
} ;
|
|
|
|
// Complain if the GPD file could not be read.
|
|
|
|
} else {
|
|
cstmp.Format(IDS_INFChk_GPDReadErr, csfspec) ;
|
|
AfxMessageBox(cstmp, MB_ICONEXCLAMATION) ;
|
|
} ;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
CINFWizView::PostINFCheckingMessage
|
|
|
|
Create the checking results window if needed and then post a message to it.
|
|
|
|
******************************************************************************/
|
|
|
|
bool CINFWizView::PostINFCheckingMessage(CString& csmsg)
|
|
{
|
|
// Clean up before continuing if the user closed the checking window.
|
|
|
|
if (m_pcicdCheckDoc && m_pcmcwCheckFrame
|
|
&& !IsWindow(m_pcmcwCheckFrame->m_hWnd)) {
|
|
m_pcicdCheckDoc = NULL ;
|
|
m_pcmcwCheckFrame = NULL ;
|
|
} ;
|
|
|
|
// Create the INF checking, error display window if one does not exist.
|
|
|
|
if (m_pcicdCheckDoc == NULL) {
|
|
m_pcicdCheckDoc = new CINFCheckDoc ;
|
|
if (m_pcicdCheckDoc == NULL)
|
|
return false ;
|
|
CString cstitle ; // Set the new window's title
|
|
cstitle.Format(IDS_INFCheckTitle, GetDocument()->GetTitle()) ;
|
|
m_pcicdCheckDoc->SetTitle(cstitle) ;
|
|
CMultiDocTemplate* pcmdt = WSCheckTemplate() ;
|
|
m_pcmcwCheckFrame = (CMDIChildWnd *) pcmdt->CreateNewFrame(m_pcicdCheckDoc, NULL) ;
|
|
if (m_pcmcwCheckFrame) {
|
|
pcmdt->InitialUpdateFrame(m_pcmcwCheckFrame, m_pcicdCheckDoc, TRUE) ;
|
|
pcmdt->AddDocument(m_pcicdCheckDoc) ;
|
|
} else {
|
|
delete m_pcicdCheckDoc ;
|
|
m_pcicdCheckDoc = NULL ;
|
|
return false ;
|
|
} ;
|
|
} ;
|
|
|
|
// Post the message and return
|
|
|
|
m_pcicdCheckDoc->PostINFChkMsg(csmsg) ;
|
|
m_bChkingErrsFound = true ;
|
|
return true ;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
CINFWizView::ResetINFErrorWindow
|
|
|
|
If there is an existing checking results window for this INF file, clear
|
|
out its contents. Next, initialize a flag that has to be set before the
|
|
checking begins.
|
|
|
|
******************************************************************************/
|
|
|
|
void CINFWizView::ResetINFErrorWindow()
|
|
{
|
|
// Clear the checking window if there is one.
|
|
|
|
if (m_pcicdCheckDoc && m_pcmcwCheckFrame && IsWindow(m_pcmcwCheckFrame->m_hWnd))
|
|
m_pcicdCheckDoc->DeleteAllMessages() ;
|
|
else {
|
|
m_pcicdCheckDoc = NULL ;
|
|
m_pcmcwCheckFrame = NULL ;
|
|
// DEAD_BUG - Do I need to delete these classes first??? // No you can't.
|
|
} ;
|
|
|
|
// Initialize checking flag
|
|
|
|
m_bChkingErrsFound = false ;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizDoc
|
|
|
|
IMPLEMENT_DYNCREATE(CINFWizDoc, CDocument)
|
|
|
|
CINFWizDoc::CINFWizDoc()
|
|
{
|
|
// This constructor is called when the File Open command is used. That is
|
|
// not supported at this point.
|
|
|
|
m_bGoodInit = false ;
|
|
}
|
|
|
|
|
|
CINFWizDoc::CINFWizDoc(CProjectRecord* pcpr, CINFWizard* pciw)
|
|
{
|
|
// Save the input parameters.
|
|
|
|
m_pcpr = pcpr ;
|
|
m_pciw = pciw ;
|
|
ASSERT(m_pciw != NULL) ;
|
|
|
|
// Class is correctly constructed.
|
|
|
|
m_bGoodInit = true ;
|
|
}
|
|
//RAID 0001
|
|
CINFWizDoc::CINFWizDoc(CGPDContainer * pcgc, CINFWizard * pciw)
|
|
{
|
|
m_pcgc = pcgc ;
|
|
m_pciw = pciw ;
|
|
ASSERT(m_pciw != NULL) ;
|
|
|
|
// Class is correctly constructed.
|
|
|
|
m_bGoodInit = true ;
|
|
|
|
}
|
|
// RAID 0001
|
|
|
|
BOOL CINFWizDoc::OnNewDocument()
|
|
{
|
|
// Creating a new INF doc in this way is not supported.
|
|
|
|
return FALSE ;
|
|
|
|
//if (!CDocument::OnNewDocument())
|
|
// return FALSE;
|
|
//return TRUE;
|
|
}
|
|
|
|
|
|
CINFWizDoc::~CINFWizDoc()
|
|
{
|
|
// Do nothing if this class was not correctly constructed.
|
|
|
|
if (!m_bGoodInit)
|
|
return ;
|
|
|
|
// Free the wizard classes if they exist.
|
|
|
|
if (m_pciw != NULL)
|
|
delete m_pciw ;
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFWizDoc, CDocument)
|
|
//{{AFX_MSG_MAP(CINFWizDoc)
|
|
// NOTE - the ClassWizard will add and remove mapping macros here.
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizDoc diagnostics
|
|
|
|
#ifdef _DEBUG
|
|
void CINFWizDoc::AssertValid() const
|
|
{
|
|
CDocument::AssertValid();
|
|
}
|
|
|
|
void CINFWizDoc::Dump(CDumpContext& dc) const
|
|
{
|
|
CDocument::Dump(dc);
|
|
}
|
|
#endif //_DEBUG
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizDoc serialization
|
|
|
|
void CINFWizDoc::Serialize(CArchive& ar)
|
|
{
|
|
unsigned unumbytes ;
|
|
CString& csinfcontents = m_pciw->m_csINFContents ;
|
|
|
|
if (ar.IsStoring())
|
|
{
|
|
unumbytes = csinfcontents.GetLength() ;
|
|
ar.Write(csinfcontents.GetBuffer(unumbytes + 10), unumbytes) ;
|
|
csinfcontents.ReleaseBuffer() ;
|
|
}
|
|
else
|
|
{
|
|
// TODO: add loading code here
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFWizDoc commands
|
|
|
|
void CINFWizDoc::OnCloseDocument()
|
|
{
|
|
// Clean up the wizard if the class was correctly constructed.
|
|
|
|
if (m_bGoodInit) {
|
|
delete m_pciw ;
|
|
m_pciw = NULL ;
|
|
} ;
|
|
|
|
CDocument::OnCloseDocument();
|
|
}
|
|
|
|
|
|
BOOL CINFWizDoc::OnOpenDocument(LPCTSTR lpszPathName)
|
|
{
|
|
// Opening an INF doc in this way is not supported so complain and exit.
|
|
|
|
CString csmsg ;
|
|
csmsg.LoadString(IDS_INFOpenError) ;
|
|
AfxMessageBox(csmsg, MB_ICONINFORMATION) ;
|
|
return FALSE ;
|
|
|
|
//if (!CDocument::OnOpenDocument(lpszPathName))
|
|
// return FALSE;
|
|
|
|
// TODO: Add your specialized creation code here
|
|
|
|
//return TRUE;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFCheckView
|
|
|
|
IMPLEMENT_DYNCREATE(CINFCheckView, CFormView)
|
|
|
|
CINFCheckView::CINFCheckView()
|
|
: CFormView(CINFCheckView::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CINFCheckView)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
CINFCheckView::~CINFCheckView()
|
|
{
|
|
}
|
|
|
|
void CINFCheckView::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CFormView::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CINFCheckView)
|
|
DDX_Control(pDX, IDC_ErrWrnLstBox, m_clbMissingFiles);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFCheckView, CFormView)
|
|
//{{AFX_MSG_MAP(CINFCheckView)
|
|
// NOTE - the ClassWizard will add and remove mapping macros here.
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFCheckView diagnostics
|
|
|
|
#ifdef _DEBUG
|
|
void CINFCheckView::AssertValid() const
|
|
{
|
|
CFormView::AssertValid();
|
|
}
|
|
|
|
void CINFCheckView::Dump(CDumpContext& dc) const
|
|
{
|
|
CFormView::Dump(dc);
|
|
}
|
|
#endif //_DEBUG
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFCheckView message handlers
|
|
|
|
/******************************************************************************
|
|
|
|
CINFCheckView::OnInitialUpdate
|
|
|
|
Resize the frame to better fit the visible controls in it.
|
|
|
|
******************************************************************************/
|
|
|
|
void CINFCheckView::OnInitialUpdate()
|
|
{
|
|
CRect crtxt ; // Coordinates of list box label
|
|
CRect crlbfrm ; // Coordinates of list box and frame
|
|
|
|
CFormView::OnInitialUpdate() ;
|
|
|
|
// Get the dimensions of the list box label
|
|
|
|
HWND hlblhandle ;
|
|
GetDlgItem(IDC_INFCLabel, &hlblhandle) ;
|
|
::GetWindowRect(hlblhandle, crtxt) ;
|
|
crtxt.NormalizeRect() ;
|
|
|
|
// Get the dimensions of the list box and then add the height of the label
|
|
// to those dimensions.
|
|
|
|
m_clbMissingFiles.GetWindowRect(crlbfrm) ;
|
|
crlbfrm.bottom += crtxt.Height() ;
|
|
|
|
// Make sure the frame is big enough for these 2 controls plus a little bit
|
|
// more.
|
|
|
|
crlbfrm.right += 40 ;
|
|
crlbfrm.bottom += 40 ;
|
|
GetParentFrame()->CalcWindowRect(crlbfrm) ;
|
|
GetParentFrame()->SetWindowPos(NULL, 0, 0, crlbfrm.Width(), crlbfrm.Height(),
|
|
SWP_NOZORDER | SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOACTIVATE) ;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
CINFCheckView::PostINFChkMsg
|
|
|
|
Add an error or warning message to the list box.
|
|
|
|
******************************************************************************/
|
|
|
|
void CINFCheckView::PostINFChkMsg(CString& csmsg)
|
|
{
|
|
int n = m_clbMissingFiles.AddString(csmsg) ;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
CINFCheckView::DeleteAllMessages
|
|
|
|
Delete all of the messages in the list box.
|
|
|
|
******************************************************************************/
|
|
|
|
void CINFCheckView::DeleteAllMessages(void)
|
|
{
|
|
m_clbMissingFiles.ResetContent() ;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFCheckDoc
|
|
|
|
IMPLEMENT_DYNCREATE(CINFCheckDoc, CDocument)
|
|
|
|
CINFCheckDoc::CINFCheckDoc()
|
|
{
|
|
}
|
|
|
|
BOOL CINFCheckDoc::OnNewDocument()
|
|
{
|
|
if (!CDocument::OnNewDocument())
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
CINFCheckDoc::~CINFCheckDoc()
|
|
{
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
CINFCheckDoc::PostINFChkMsg
|
|
|
|
Pass the specified request on to what should be the one and only view
|
|
attached to this document.
|
|
|
|
******************************************************************************/
|
|
|
|
void CINFCheckDoc::PostINFChkMsg(CString& csmsg)
|
|
{
|
|
POSITION pos = GetFirstViewPosition() ;
|
|
if (pos != NULL) {
|
|
CINFCheckView* pcicv = (CINFCheckView *) GetNextView(pos) ;
|
|
pcicv->PostINFChkMsg(csmsg) ;
|
|
pcicv->UpdateWindow() ;
|
|
} ;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
CINFCheckDoc::DeleteAllMessages
|
|
|
|
Pass the specified request on to what should be the one and only view
|
|
attached to this document.
|
|
|
|
******************************************************************************/
|
|
|
|
void CINFCheckDoc::DeleteAllMessages(void)
|
|
{
|
|
POSITION pos = GetFirstViewPosition() ;
|
|
if (pos != NULL) {
|
|
CINFCheckView* pcicv = (CINFCheckView *) GetNextView(pos) ;
|
|
pcicv->DeleteAllMessages() ;
|
|
pcicv->UpdateWindow() ;
|
|
} ;
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CINFCheckDoc, CDocument)
|
|
//{{AFX_MSG_MAP(CINFCheckDoc)
|
|
// NOTE - the ClassWizard will add and remove mapping macros here.
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFCheckDoc diagnostics
|
|
|
|
#ifdef _DEBUG
|
|
void CINFCheckDoc::AssertValid() const
|
|
{
|
|
CDocument::AssertValid();
|
|
}
|
|
|
|
void CINFCheckDoc::Dump(CDumpContext& dc) const
|
|
{
|
|
CDocument::Dump(dc);
|
|
}
|
|
#endif //_DEBUG
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CINFCheckDoc serialization
|
|
|
|
void CINFCheckDoc::Serialize(CArchive& ar)
|
|
{
|
|
if (ar.IsStoring())
|
|
{
|
|
// TODO: add storing code here
|
|
}
|
|
else
|
|
{
|
|
// TODO: add loading code here
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Construction/Destruction
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
CCompatID::CCompatID( CString csMfg, CString csModel )
|
|
{
|
|
// Save the Parameters
|
|
m_csMfg = csMfg;
|
|
m_csModel = csModel;
|
|
}
|
|
|
|
|
|
CCompatID::~CCompatID()
|
|
{
|
|
|
|
}
|
|
|
|
|
|
void CCompatID::TransString(CString &csInput)
|
|
{
|
|
// Walk Through the String changing Spaces to Underscores
|
|
DWORD i;
|
|
TCHAR cszSpace[] = TEXT(" ");
|
|
TCHAR cszUS[] = TEXT("_");
|
|
DWORD dwLength = csInput.GetLength();
|
|
|
|
for ( i = 0; i < dwLength; i++ )
|
|
{
|
|
if (csInput.GetAt(i) == cszSpace[0])
|
|
csInput.SetAt(i, cszUS[0]);
|
|
}
|
|
}
|
|
|
|
|
|
USHORT CCompatID::GetCheckSum(CString csValue)
|
|
{
|
|
WORD wCRC16a[16]={
|
|
0000000, 0140301, 0140601, 0000500,
|
|
0141401, 0001700, 0001200, 0141101,
|
|
0143001, 0003300, 0003600, 0143501,
|
|
0002400, 0142701, 0142201, 0002100,
|
|
};
|
|
|
|
WORD wCRC16b[16]={
|
|
0000000, 0146001, 0154001, 0012000,
|
|
0170001, 0036000, 0024000, 0162001,
|
|
0120001, 0066000, 0074000, 0132001,
|
|
0050000, 0116001, 0104001, 0043000,
|
|
};
|
|
|
|
BYTE byte;
|
|
USHORT CS=0;
|
|
DWORD dwSize = csValue.GetLength();
|
|
PBYTE ptr = (PBYTE) csValue.GetBuffer(dwSize);
|
|
|
|
dwSize *= sizeof(TCHAR);
|
|
|
|
for ( ; dwSize ; --dwSize, ++ptr) {
|
|
|
|
byte = (BYTE)(((WORD)*ptr)^((WORD)CS)); // Xor CRC with new char
|
|
CS = ((CS)>>8) ^ wCRC16a[byte&0x0F] ^ wCRC16b[byte>>4];
|
|
}
|
|
csValue.ReleaseBuffer();
|
|
|
|
return CS;
|
|
}
|
|
|
|
|
|
void CCompatID::GenerateID(CString &csCompID)
|
|
{
|
|
CString csTransModel, csMfgModel;
|
|
|
|
// Build the Mfg Model string
|
|
csMfgModel = m_csMfg;
|
|
csMfgModel += m_csModel;
|
|
|
|
// Convert the spaces to underscores
|
|
TransString( csMfgModel );
|
|
|
|
csTransModel = m_csModel;
|
|
TransString( csTransModel );
|
|
|
|
csCompID = csMfgModel;
|
|
|
|
// Get the CheckSum
|
|
USHORT usCheckSum = GetCheckSum( csCompID );
|
|
|
|
|
|
// Now chop off the Mfg/Model string if too Long.
|
|
if ( csCompID.GetLength() > MAX_DEVNODE_NAME_ROOT )
|
|
{
|
|
csCompID.GetBufferSetLength(MAX_DEVNODE_NAME_ROOT);
|
|
csCompID.ReleaseBuffer();
|
|
}
|
|
|
|
TCHAR szCheckSum[6] = { 0x00 };
|
|
// _itot( usCheckSum, szCheckSum, 16 );
|
|
StringCchPrintf( szCheckSum, CCHOF(szCheckSum), _T("%04X"), usCheckSum );
|
|
csCompID +=szCheckSum;
|
|
|
|
//csCompID += TEXT(",");
|
|
//csCompID += csTransModel;
|
|
}
|
|
|