зеркало из https://github.com/mozilla/pjs.git
1322 строки
32 KiB
C++
1322 строки
32 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public License
|
|
* Version 1.0 (the "NPL"); you may not use this file except in
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
* for the specific language governing rights and limitations under the
|
|
* NPL.
|
|
*
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
* Reserved.
|
|
*/
|
|
|
|
|
|
// WizardMachine.cpp : Defines the class behaviors for the application.
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "WizardMachine.h"
|
|
#include <iostream.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <direct.h>
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CWizardMachineApp
|
|
|
|
BEGIN_MESSAGE_MAP(CWizardMachineApp, CWinApp)
|
|
//{{AFX_MSG_MAP(CWizardMachineApp)
|
|
// NOTE - the ClassWizard will add and remove mapping macros here.
|
|
// DO NOT EDIT what you see in these blocks of generated code!
|
|
//}}AFX_MSG
|
|
ON_COMMAND(ID_HELP, CWinApp::OnHelp)
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CWizardMachineApp construction
|
|
|
|
CWizardMachineApp::CWizardMachineApp()
|
|
{
|
|
// TODO: add construction code here,
|
|
// Place all significant initialization in InitInstance
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// The one and only CWizardMachineApp object
|
|
CPropSheet* PropertySheetDlg;
|
|
|
|
CWizardMachineApp theApp;
|
|
NODE *GlobalDefaults;
|
|
NODE *WizardTree;
|
|
NODE *CurrentNode;
|
|
WIDGET GlobalWidgetArray[1000];
|
|
|
|
int GlobalArrayIndex=0;
|
|
int CurrentPageBaseIndex=100;
|
|
|
|
CString Path;
|
|
char currDirPath[MAX_SIZE];
|
|
char iniFilePath[MAX_SIZE];
|
|
char imagesPath[MAX_SIZE];
|
|
char rootPath[MAX_SIZE];
|
|
char customizationPath[MAX_SIZE];
|
|
|
|
CString CacheFile;
|
|
BOOL UseCache = FALSE;
|
|
extern CSingleLock prevLock;
|
|
extern BOOL isBuildInstaller;
|
|
//Output file pointer for QA purposes
|
|
FILE *out, *globs;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CWizardMachineApp initialization
|
|
|
|
BOOL CWizardMachineApp::InitInstance()
|
|
{
|
|
// Standard initialization
|
|
// If you are not using these features and wish to reduce the size
|
|
// of your final executable, you should remove from the following
|
|
// the specific initialization routines you do not need.
|
|
|
|
#ifdef _AFXDLL
|
|
Enable3dControls(); // Call this when using MFC in a shared DLL
|
|
#else
|
|
Enable3dControlsStatic(); // Call this when linking to MFC statically
|
|
#endif
|
|
|
|
CWnd myWnd;
|
|
|
|
//Do initializations
|
|
//Check for comm existence
|
|
//declare a tree for nodes
|
|
|
|
Path = GetModulePath();
|
|
|
|
//_getcwd(currDirPath, MAX_SIZE);
|
|
//strcat(currDirPath, "\\");
|
|
strcpy(currDirPath, Path);
|
|
|
|
CString outputFile = Path + "output.dat";
|
|
out = OpenAFile(outputFile, "w");
|
|
|
|
//char buffer[MID_SIZE];
|
|
char **argv;
|
|
int argc;
|
|
|
|
// 10 argument limit
|
|
argv = (char **) GlobalAlloc(0, sizeof(char *) * 10);
|
|
|
|
int i=0;
|
|
// Each argument limited to 100 chars
|
|
argv[i] = (char *) GlobalAlloc(0, sizeof(char) * MIN_SIZE);
|
|
argv[i] = strtok(m_lpCmdLine," ");
|
|
while(argv[i])
|
|
{
|
|
argv[++i] = (char *) GlobalAlloc(0, sizeof(char) * MIN_SIZE);
|
|
argv[i] = strtok(NULL," ");
|
|
}
|
|
|
|
argc = --i;
|
|
|
|
CString iniFile;
|
|
CString action;
|
|
|
|
for (i=0; i < argc; i++)
|
|
{
|
|
if (!strcmp(argv[i], "-i"))
|
|
iniFile = argv[i+1];
|
|
if (!strcmp(argv[i], "-p"))
|
|
action = argv[i+1];
|
|
}
|
|
|
|
if (iniFile.GetLength() < 5)
|
|
{
|
|
myWnd.MessageBox("Please provide a valid inifile name.", "ERROR", MB_OK);
|
|
fprintf(out, "----------------** TERMINATED - Invalid INI file name **---------------\n");
|
|
exit(1);
|
|
}
|
|
|
|
for (i=iniFile.GetLength() -1; i >= 0 && iniFile[i] != '\\'; i--)
|
|
{
|
|
if (iniFile.GetAt(i) == '/' ) {
|
|
iniFile.SetAt(i,(TCHAR)'\\');
|
|
}
|
|
}
|
|
|
|
char tmpStr[MAX_SIZE] = {'\0'};
|
|
if (strstr(iniFile,"iniFiles")) {
|
|
strncpy(tmpStr, iniFile, strlen(iniFile) - strlen(strstr(iniFile,"iniFiles")));
|
|
}
|
|
|
|
strcat(currDirPath, "..\\..\\");
|
|
|
|
strcpy(iniFilePath, currDirPath);
|
|
//strcat(iniFilePath, "..\\");
|
|
strcpy(imagesPath, currDirPath);
|
|
//strcat(imagesPath, "..\\");
|
|
|
|
if (tmpStr) {
|
|
strcat(iniFilePath, tmpStr);
|
|
strcat(imagesPath, tmpStr);
|
|
|
|
strcpy(customizationPath, currDirPath);
|
|
//strcat(customizationPath, "..\\");
|
|
strcat(customizationPath, tmpStr);
|
|
strcat(customizationPath, "customizations\\");
|
|
}
|
|
|
|
strcat(iniFilePath, "iniFiles\\");
|
|
strcat(imagesPath, "bitmaps\\");
|
|
|
|
char* baseIniFile;
|
|
if (strrchr(iniFile,'\\')) {
|
|
baseIniFile = new char[MAX_SIZE];
|
|
strcpy(baseIniFile, strrchr(iniFile,'\\'));
|
|
baseIniFile++;
|
|
}
|
|
|
|
CString cacheExt = ".che";
|
|
CacheFile = CString(baseIniFile);
|
|
CacheFile = CacheFile.GetBufferSetLength(CacheFile.Find(".ini")) + cacheExt;
|
|
|
|
char buffer[MAX_SIZE] = {'\0'};
|
|
if (FileExists(Path+CacheFile))
|
|
{
|
|
UseCache = TRUE;
|
|
globs = OpenAFile(Path + CacheFile, "r");
|
|
FillGlobalWidgetArray();
|
|
fclose(globs);
|
|
}
|
|
|
|
fprintf(out, "___________________________________________________________\n\n");
|
|
fprintf(out, "ACTION SEQUENCE : %s\n", action);
|
|
fprintf(out, "___________________________________________________________\n\n");
|
|
|
|
SetGlobalDefaults();
|
|
|
|
InitializeTree(CString(baseIniFile));
|
|
CreateFirstLeaf(WizardTree, CString(iniFilePath) + CString(baseIniFile));
|
|
|
|
//BEGIN - Command line QA enable code
|
|
/**
|
|
i=0;
|
|
while(i < action.GetLength())
|
|
{
|
|
ExecuteAction(action.GetAt(i));
|
|
i++;
|
|
}
|
|
|
|
CreateNewCache();
|
|
|
|
fprintf(out, "---------------------**** END ****-------------------------\n");
|
|
|
|
myWnd.MessageBox(CurrentNode->localVars->pageName, "Netscape", MB_OK);
|
|
|
|
exit(0);
|
|
**/
|
|
//END - Command line QA enable code
|
|
|
|
//CProgressDialog ProgressDialog;
|
|
PropertySheetDlg = new CPropSheet(IDD_WIZARDMACHINE_DIALOG);
|
|
//CWizardMachineDlg* myWndTmp;
|
|
|
|
CWizardUI* pages[99];
|
|
//CMyProgressDlg ProgressDialog(myWndTmp);
|
|
//ProgressDialog.Create(IDD_PROGRESS_DLG);
|
|
//CMyProgressDlg *pProgressDlg = &ProgressDialog;
|
|
|
|
for (int x = 0; x < 99; x++) {
|
|
pages[x] = new CWizardUI;
|
|
PropertySheetDlg->AddPage (pages[x]);
|
|
}
|
|
|
|
PropertySheetDlg->SetWizardMode();
|
|
int PageReturnValue = PropertySheetDlg->DoModal();
|
|
delete(PropertySheetDlg);
|
|
|
|
if (PageReturnValue == ID_WIZFINISH)
|
|
{
|
|
if (!isBuildInstaller) {
|
|
theApp.CreateNewCache();
|
|
|
|
NODE* tmpNode = WizardTree->childNodes[0];
|
|
while (!tmpNode->numWidgets) {
|
|
tmpNode = tmpNode->childNodes[0];
|
|
}
|
|
|
|
CurrentNode = tmpNode;
|
|
}
|
|
}
|
|
|
|
if (PageReturnValue == IDCANCEL)
|
|
{
|
|
theApp.CreateNewCache();
|
|
|
|
/**
|
|
NODE* tmpNode = WizardTree->childNodes[0];
|
|
while (!tmpNode->numWidgets) {
|
|
tmpNode = tmpNode->childNodes[0];
|
|
}
|
|
|
|
CurrentNode = tmpNode;
|
|
**/
|
|
}
|
|
|
|
|
|
//CreateNewCache();
|
|
|
|
fprintf(out, "---------------------**** END ****-------------------------\n");
|
|
|
|
|
|
// Since the dialog has been closed, return FALSE so that we exit the
|
|
// application, rather than start the application's message pump.
|
|
return FALSE;
|
|
}
|
|
|
|
////Add Wizard machine functions here.
|
|
//Define OnEnter function
|
|
//Define OnExit function
|
|
//Define ExitApp function
|
|
//Define GoToNextNode function
|
|
//Define GoToPrevNode function
|
|
//Define GetGlobal function
|
|
//Define SetGlobal function
|
|
|
|
void CWizardMachineApp::InitializeTree(CString rootIniFile)
|
|
{
|
|
WizardTree = CreateNode(GlobalDefaults, rootIniFile);
|
|
PrintNodeInfo(WizardTree);
|
|
}
|
|
|
|
|
|
|
|
//Create Node
|
|
NODE* CWizardMachineApp::CreateNode(NODE *parentNode, CString iniFile)
|
|
{
|
|
|
|
char buffer[MAX_SIZE]= { '\0' };
|
|
char visibility[MIN_SIZE] = {'\0'};
|
|
CString pagesSection = "Sub Pages";
|
|
CString varSection = "Local Variables";
|
|
CString navCtrlSection = "Navigation Controls";
|
|
CString widgetSection = "Widget";
|
|
CString imageSection = "Image";
|
|
CStringArray bufferArray;
|
|
NODE* NewNode = (NODE *) GlobalAlloc(0,sizeof(NODE) * 1);
|
|
|
|
NewNode->parent = parentNode;
|
|
|
|
iniFile = CString(iniFilePath)+iniFile; //Path+iniFile;
|
|
|
|
CheckIniFileExistence(iniFile);
|
|
|
|
GetPrivateProfileString(pagesSection, NULL, "", buffer, MAX_SIZE, iniFile);
|
|
|
|
NewNode->numChildNodes = GetBufferCount(buffer);
|
|
NewNode->currNodeIndex = 0;
|
|
|
|
NewNode->subPages = new PAGE;
|
|
|
|
int numHidePages = 0;
|
|
for (int i=0; i < NewNode->numChildNodes ; i++)
|
|
{
|
|
CString page = GetBufferElement(buffer, i);
|
|
|
|
GetPrivateProfileString(pagesSection, page, "", visibility, MAX_SIZE, iniFile);
|
|
|
|
CString visible = CString(visibility);
|
|
CString tmpVisible = CString(visibility);
|
|
visible.MakeUpper();
|
|
visible.TrimRight();
|
|
if ( visible != "HIDE")
|
|
{
|
|
NewNode->subPages->pages.Add(page);
|
|
NewNode->subPages->visibility.Add(tmpVisible);
|
|
}
|
|
else
|
|
{
|
|
numHidePages++;
|
|
}
|
|
}
|
|
|
|
NewNode->numChildNodes = NewNode->numChildNodes - numHidePages;
|
|
|
|
NewNode->childNodes = (NODE **) GlobalAlloc(0,NewNode->numChildNodes * sizeof(NODE *));
|
|
|
|
for (i=0; i < NewNode->numChildNodes ; i++)
|
|
{
|
|
NewNode->childNodes[i] = NULL;
|
|
}
|
|
|
|
NewNode->localVars = new VARS;
|
|
GetPrivateProfileString(varSection, "Title", "", buffer, MAX_SIZE, iniFile);
|
|
NewNode->localVars->title = buffer;
|
|
GetPrivateProfileString(varSection, "Caption", "", buffer, MAX_SIZE, iniFile);
|
|
NewNode->localVars->caption = buffer;
|
|
GetPrivateProfileString(varSection, "Function", "", buffer, MAX_SIZE, iniFile);
|
|
NewNode->localVars->functionality = buffer;
|
|
|
|
CString tempPageVar = "";
|
|
|
|
int index = iniFile.ReverseFind('\\');
|
|
if (index != -1)
|
|
{
|
|
for (int j=index+1 ; j < iniFile.GetLength() ; j++)
|
|
{
|
|
char element = iniFile.GetAt(j);
|
|
if (element == '.')
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
tempPageVar += element;
|
|
}
|
|
}
|
|
}
|
|
|
|
NewNode->localVars->pageName = tempPageVar;
|
|
|
|
|
|
GetPrivateProfileString(varSection, "image", "", buffer, MAX_SIZE, iniFile);
|
|
NewNode->localVars->image = buffer;
|
|
GetPrivateProfileString(varSection, "Visibility", "", buffer, MAX_SIZE, iniFile);
|
|
NewNode->localVars->visibility = buffer;
|
|
|
|
NewNode->navControls = new CONTROLS;
|
|
GetPrivateProfileString(navCtrlSection, "OnNext", "", buffer, MAX_SIZE, iniFile);
|
|
NewNode->navControls->onNextAction = buffer;
|
|
GetPrivateProfileString(navCtrlSection, "Help", "", buffer, MAX_SIZE, iniFile);
|
|
NewNode->navControls->helpFile = buffer;
|
|
|
|
NewNode->pageWidgets = (WIDGET **) GlobalAlloc(0, MIN_SIZE * sizeof(WIDGET *));
|
|
NewNode->numWidgets = 0;
|
|
NewNode->currWidgetIndex = 0;
|
|
|
|
NewNode->pageBaseIndex = CurrentPageBaseIndex;
|
|
CurrentPageBaseIndex += MIN_SIZE;
|
|
|
|
// MAX 20 images/page ....?
|
|
NewNode->images = (IMAGE **) GlobalAlloc(0, 20 * sizeof(IMAGE *));
|
|
NewNode->numImages = 0;
|
|
|
|
char sectionBuffer[MID_SIZE];
|
|
GetPrivateProfileString(NULL, NULL, "", sectionBuffer, MAX_SIZE, iniFile);
|
|
char iniSection[MID_SIZE];
|
|
|
|
int idCounter=0;
|
|
for (i=0; i < GetBufferCount(sectionBuffer); i++)
|
|
{
|
|
strcpy(iniSection,GetBufferElement(sectionBuffer, i));
|
|
|
|
if(strstr(iniSection, widgetSection))
|
|
{
|
|
char localBuffer[MAX_SIZE] = {'\0'};
|
|
|
|
//GlobalWidgetArray[GlobalArrayIndex].cached = TRUE;
|
|
|
|
GetPrivateProfileString(iniSection, "Name", "", buffer, MAX_SIZE, iniFile);
|
|
strcpy(localBuffer, buffer);
|
|
|
|
WIDGET* widgetEntry = findWidget(buffer);
|
|
|
|
if (widgetEntry)
|
|
{
|
|
if (!widgetEntry->cached)
|
|
{
|
|
prevLock.Lock();
|
|
CWnd myWnd;
|
|
myWnd.MessageBox("Duplicate Widget Entry " + CString(buffer) + " detected : "+ NewNode->localVars->pageName , "Error", MB_ICONSTOP | MB_SYSTEMMODAL);
|
|
prevLock.Unlock();
|
|
exit(7);
|
|
}
|
|
else
|
|
{
|
|
BOOL readValue = FALSE;
|
|
if (widgetEntry->value == "")
|
|
{
|
|
readValue = TRUE;
|
|
}
|
|
BuildWidget(widgetEntry, iniSection, iniFile, NewNode->pageBaseIndex, readValue);
|
|
|
|
widgetEntry->cached = FALSE;
|
|
NewNode->pageWidgets[NewNode->numWidgets] = widgetEntry;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BOOL readValue = TRUE;
|
|
GlobalWidgetArray[GlobalArrayIndex].cached = TRUE;
|
|
|
|
BuildWidget(&GlobalWidgetArray[GlobalArrayIndex], iniSection, iniFile, NewNode->pageBaseIndex, readValue);
|
|
GlobalWidgetArray[GlobalArrayIndex].cached = FALSE;
|
|
|
|
NewNode->pageWidgets[NewNode->numWidgets] = &GlobalWidgetArray[GlobalArrayIndex];
|
|
GlobalArrayIndex++;
|
|
}
|
|
|
|
(NewNode->numWidgets)++;
|
|
|
|
}
|
|
else if(strstr(iniSection, imageSection))
|
|
{
|
|
int index = NewNode->numImages;
|
|
|
|
// This allows dynamic buffer allocation to CString vars
|
|
NewNode->images[index] = new IMAGE;
|
|
|
|
GetPrivateProfileString(iniSection, "Name", "", buffer, MAX_SIZE, iniFile);
|
|
NewNode->images[index]->name = CString(imagesPath) + CString(buffer);
|
|
|
|
GetPrivateProfileString(iniSection, "Value", "", buffer, MAX_SIZE, iniFile);
|
|
NewNode->images[index]->value = buffer;
|
|
|
|
GetPrivateProfileString(iniSection, "start_X", "", buffer, MAX_SIZE, iniFile);
|
|
NewNode->images[index]->location.x = atoi(buffer);
|
|
|
|
GetPrivateProfileString(iniSection, "start_Y", "", buffer, MAX_SIZE, iniFile);
|
|
NewNode->images[index]->location.y = atoi(buffer);
|
|
|
|
GetPrivateProfileString(iniSection, "width", "", buffer, MAX_SIZE, iniFile);
|
|
NewNode->images[index]->size.width = atoi(buffer);
|
|
|
|
GetPrivateProfileString(iniSection, "height", "", buffer, MAX_SIZE, iniFile);
|
|
NewNode->images[index]->size.height = atoi(buffer);
|
|
|
|
NewNode->images[index]->hBitmap = (HBITMAP)LoadImage(NULL, NewNode->images[index]->name, IMAGE_BITMAP, 0, 0,
|
|
LR_LOADFROMFILE|LR_CREATEDIBSECTION);
|
|
|
|
(NewNode->numImages)++;
|
|
}
|
|
}
|
|
|
|
parentNode->childNodes[parentNode->currNodeIndex] = NewNode;
|
|
|
|
CurrentNode = NewNode;
|
|
|
|
//PrintNodeInfo(CurrentNode);
|
|
|
|
return NewNode;
|
|
}
|
|
|
|
//Create Node
|
|
void CWizardMachineApp::CreateNode()
|
|
{
|
|
GlobalDefaults = (NODE *) GlobalAlloc(0,sizeof(NODE) * 1);
|
|
|
|
GlobalDefaults->parent = NULL;
|
|
|
|
GlobalDefaults->childNodes = (NODE **) GlobalAlloc(0,1 * sizeof(NODE *));
|
|
GlobalDefaults->numChildNodes = 1;
|
|
GlobalDefaults->currNodeIndex = 0;
|
|
GlobalDefaults->childNodes[GlobalDefaults->currNodeIndex] = NULL;
|
|
|
|
|
|
GlobalDefaults->localVars = new VARS;
|
|
GlobalDefaults->localVars->title = "Globals";
|
|
GlobalDefaults->localVars->caption = "Globals";
|
|
GlobalDefaults->localVars->pageName = "Globals";
|
|
GlobalDefaults->localVars->image = "Globals";
|
|
|
|
GlobalDefaults->subPages = NULL;
|
|
GlobalDefaults->navControls = NULL;
|
|
GlobalDefaults->pageWidgets = NULL;
|
|
GlobalDefaults->numWidgets = 0;
|
|
GlobalDefaults->currWidgetIndex = 0;
|
|
|
|
CurrentNode = GlobalDefaults;
|
|
|
|
PrintNodeInfo(CurrentNode);
|
|
|
|
}
|
|
|
|
|
|
void CWizardMachineApp::SetGlobalDefaults()
|
|
{
|
|
CreateNode();
|
|
}
|
|
|
|
void CWizardMachineApp::CreateFirstLeaf(NODE *parent, CString iniFile)
|
|
{
|
|
NODE* currNode = parent;
|
|
CString section = "Sub Pages";
|
|
char buffer[MAX_SIZE] = {'\0'};
|
|
CString iniName;
|
|
|
|
|
|
iniName = iniFile;
|
|
|
|
while (SectionFound(iniName, section))
|
|
{
|
|
CString visibleChild;
|
|
char localBuffer[MAX_SIZE];
|
|
int i = 0;
|
|
GetPrivateProfileString(section, NULL, "", buffer, MAX_SIZE, iniName);
|
|
GetPrivateProfileString(section, GetBufferElement(buffer, i), "", localBuffer, MAX_SIZE, iniName);
|
|
|
|
CString visible = CString(localBuffer);
|
|
visible.MakeUpper();
|
|
visible.TrimRight();
|
|
|
|
while (visible == "HIDE")
|
|
{
|
|
i++;
|
|
GetPrivateProfileString(section, GetBufferElement(buffer, i), "", localBuffer, MAX_SIZE, iniName);
|
|
|
|
visible = CString(localBuffer);
|
|
visible.MakeUpper();
|
|
}
|
|
|
|
visibleChild = GetBufferElement(buffer, i);
|
|
|
|
if (visibleChild + ".ini" == ".ini")
|
|
{
|
|
CWnd myWnd;
|
|
CString message = "No pages to display.....!";
|
|
myWnd.MessageBox(message, "ERROR", MB_OK);
|
|
fprintf(out, "------------** TERMINATED - No pages to display **----------------\n");
|
|
exit(8);
|
|
}
|
|
|
|
currNode->childNodes[0] = CreateNode(currNode, visibleChild + ".ini");
|
|
currNode = currNode->childNodes[0];
|
|
|
|
iniName = iniFilePath + visibleChild + ".ini";
|
|
|
|
PrintNodeInfo(CurrentNode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
BOOL CWizardMachineApp::SectionFound(CString iniFile, CString section)
|
|
{
|
|
char buffer[MAX_SIZE] = {'\0'};
|
|
|
|
CheckIniFileExistence(iniFile);
|
|
|
|
GetPrivateProfileString(section, NULL, "", buffer, MIN_SIZE, iniFile);
|
|
|
|
return (buffer[0] != '\0');
|
|
}
|
|
|
|
int CWizardMachineApp::GetBufferCount(char *buffer)
|
|
{
|
|
int i=0;
|
|
int j=0;
|
|
|
|
if (!buffer[1] && !buffer[2])
|
|
return 0;
|
|
|
|
BOOL streamEnd = FALSE;
|
|
while (!streamEnd)
|
|
{
|
|
while (buffer[++i])
|
|
;
|
|
j++;
|
|
|
|
if (buffer[i+1] == '\0')
|
|
streamEnd = TRUE;
|
|
}
|
|
return j;
|
|
}
|
|
|
|
char* CWizardMachineApp::GetBufferElement(const char *buffer, int index)
|
|
{
|
|
static char localBuffer[MID_SIZE];
|
|
|
|
for (int i=0; i < MID_SIZE; i++)
|
|
localBuffer[i] = '\0';
|
|
|
|
int j=0, k=0;
|
|
i=0;
|
|
BOOL streamEnd = FALSE;
|
|
BOOL elementFound = FALSE;
|
|
while (!streamEnd)
|
|
{
|
|
while (buffer[i])
|
|
{
|
|
if (j == index)
|
|
{
|
|
localBuffer[k] = buffer[i];
|
|
elementFound = TRUE;
|
|
k++;
|
|
}
|
|
i++;
|
|
}
|
|
|
|
if (elementFound)
|
|
{
|
|
break;
|
|
}
|
|
|
|
j++;
|
|
|
|
if (buffer[i+1] == '\0')
|
|
streamEnd = TRUE;
|
|
else
|
|
i++;
|
|
}
|
|
|
|
return localBuffer;
|
|
|
|
}
|
|
|
|
char* CWizardMachineApp::GetSectionBuffer(CString iniFile, CString section)
|
|
{
|
|
static char localBuffer[MID_SIZE];
|
|
|
|
CheckIniFileExistence(iniFile);
|
|
|
|
for (int i=0; i < MID_SIZE; i++)
|
|
localBuffer[i] = '\0';
|
|
|
|
GetPrivateProfileString(section, NULL, "", localBuffer, MID_SIZE, iniFile);
|
|
|
|
return localBuffer;
|
|
|
|
}
|
|
|
|
void CWizardMachineApp::ExecuteAction(char action)
|
|
{
|
|
|
|
switch(action)
|
|
{
|
|
case 'n' :
|
|
fprintf(out, "** NEXT : Begin **\n");
|
|
fprintf(out, "-----------------------------------------------------------\n");
|
|
GoToNextNode();
|
|
fprintf(out, "** NEXT : End **\n");
|
|
fprintf(out, "-----------------------------------------------------------\n");
|
|
break;
|
|
|
|
case 'b' :
|
|
fprintf(out, "** BACK : Begin **\n");
|
|
fprintf(out, "-----------------------------------------------------------\n");
|
|
GoToPrevNode();
|
|
fprintf(out, "** BACK : End **\n");
|
|
fprintf(out, "-----------------------------------------------------------\n");
|
|
break;
|
|
|
|
case 'c':
|
|
fprintf(out, "---------------------*** CANCEL ***------------------------\n");
|
|
fprintf(out, "-----------------** TERMINATED - User Cancelled App **-----------------\n");
|
|
ExitApp();
|
|
exit(0);
|
|
break;
|
|
|
|
default :
|
|
CWnd myWnd;
|
|
char temp[MIN_SIZE] = {action};
|
|
myWnd.MessageBox(strcat("Unknown Action : ", temp), "ERROR", MB_OK);
|
|
fprintf(out, "---------------** TERMINATED - Invalid Action Element **---------------\n");
|
|
exit(6);
|
|
}
|
|
}
|
|
|
|
void CWizardMachineApp::GoToNextNode()
|
|
{
|
|
//check if it is a container node
|
|
//for now check existence of display information
|
|
//go to first child and so on
|
|
|
|
//check for specialized actions
|
|
//OnNext action for that node
|
|
|
|
NODE* tmpParentNode;
|
|
|
|
tmpParentNode = CurrentNode->parent;
|
|
|
|
while (tmpParentNode->localVars->pageName != "Globals")
|
|
{
|
|
|
|
PrintNodeInfo(tmpParentNode);
|
|
|
|
if ((tmpParentNode->currNodeIndex + 1) < tmpParentNode->numChildNodes)
|
|
{
|
|
tmpParentNode->currNodeIndex++;
|
|
|
|
NODE* siblingNode = tmpParentNode->childNodes[tmpParentNode->currNodeIndex];
|
|
|
|
if (siblingNode)
|
|
{
|
|
CurrentNode = siblingNode;
|
|
//CurrentNode = tmpParentNode->childNodes[tmpParentNode->currNodeIndex];
|
|
}
|
|
else
|
|
{
|
|
CurrentNode = CreateNode(tmpParentNode, tmpParentNode->subPages->pages.GetAt(tmpParentNode->currNodeIndex) + ".ini");
|
|
//tmpParentNode->childNodes[tmpParentNode->currNodeIndex] = CreateNode(tmpParentNode, tmpParentNode->subPages->pages.GetAt(tmpParentNode->currNodeIndex) + ".ini");
|
|
}
|
|
|
|
|
|
|
|
BOOL isAContainerNode;
|
|
BOOL haveChildNodes = TRUE;
|
|
|
|
isAContainerNode = (CurrentNode->numWidgets == 0);
|
|
while(isAContainerNode && haveChildNodes)
|
|
{
|
|
NODE* containerNode = CurrentNode;
|
|
if (containerNode->numChildNodes > 0)
|
|
{
|
|
CurrentNode = containerNode->childNodes[0];
|
|
if (!CurrentNode)
|
|
{
|
|
CurrentNode = CreateNode(containerNode, containerNode->subPages->pages.GetAt(0) + ".ini");
|
|
}
|
|
isAContainerNode = (CurrentNode->numWidgets == 0);
|
|
PrintNodeInfo(containerNode);
|
|
haveChildNodes = TRUE;
|
|
}
|
|
else
|
|
{
|
|
haveChildNodes = FALSE;
|
|
}
|
|
}
|
|
PrintNodeInfo(CurrentNode);
|
|
if (haveChildNodes)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tmpParentNode = tmpParentNode->parent;
|
|
}
|
|
}
|
|
if (tmpParentNode->localVars->pageName == "Globals")
|
|
{
|
|
CWnd myWnd;
|
|
myWnd.MessageBox("Can't go past the last node", "Error", MB_OK);
|
|
fprintf(out, "------------** TERMINATED - Can't go past the last page **----------------\n");
|
|
exit(10);
|
|
}
|
|
}
|
|
|
|
|
|
void CWizardMachineApp::GoToPrevNode()
|
|
{
|
|
|
|
//check if it is a container node
|
|
//for now check existence of display information
|
|
//go to last child and so on
|
|
|
|
|
|
NODE* tmpParentNode;
|
|
|
|
tmpParentNode = CurrentNode->parent;
|
|
|
|
while (tmpParentNode->localVars->pageName != "Globals")
|
|
{
|
|
|
|
PrintNodeInfo(tmpParentNode);
|
|
|
|
if (tmpParentNode->currNodeIndex > 0)
|
|
{
|
|
tmpParentNode->currNodeIndex--;
|
|
|
|
NODE* siblingNode = tmpParentNode->childNodes[tmpParentNode->currNodeIndex];
|
|
|
|
if (siblingNode)
|
|
{
|
|
CurrentNode = siblingNode;
|
|
//CurrentNode = tmpParentNode->childNodes[tmpParentNode->currNodeIndex];
|
|
}
|
|
else
|
|
{
|
|
CurrentNode = CreateNode(tmpParentNode, tmpParentNode->subPages->pages.GetAt(tmpParentNode->currNodeIndex) + ".ini");
|
|
//tmpParentNode->childNodes[tmpParentNode->currNodeIndex] = CreateNode(tmpParentNode, tmpParentNode->subPages->pages.GetAt(tmpParentNode->currNodeIndex) + ".ini");
|
|
}
|
|
|
|
BOOL isAContainerNode;
|
|
BOOL haveChildNodes = TRUE;
|
|
|
|
isAContainerNode = (CurrentNode->numWidgets == 0);
|
|
while(isAContainerNode && haveChildNodes)
|
|
{
|
|
NODE* containerNode = CurrentNode;
|
|
|
|
if (containerNode->numChildNodes > 0)
|
|
{
|
|
int index = containerNode->currNodeIndex;
|
|
CurrentNode = containerNode->childNodes[index];
|
|
if (!CurrentNode)
|
|
{
|
|
CurrentNode = CreateNode(containerNode, containerNode->subPages->pages.GetAt(index) + ".ini");
|
|
}
|
|
isAContainerNode = (CurrentNode->numWidgets == 0);
|
|
PrintNodeInfo(containerNode);
|
|
}
|
|
else
|
|
{
|
|
haveChildNodes = FALSE;
|
|
}
|
|
}
|
|
|
|
PrintNodeInfo(CurrentNode);
|
|
if (haveChildNodes)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tmpParentNode = tmpParentNode->parent;
|
|
}
|
|
}
|
|
if (tmpParentNode->localVars->pageName == "Globals")
|
|
{
|
|
CWnd myWnd;
|
|
myWnd.MessageBox("Can't go back from first node", "Error", MB_OK);
|
|
fprintf(out, "------------** TERMINATED - Can't go back from first page **----------------\n");
|
|
exit(9);
|
|
}
|
|
|
|
}
|
|
|
|
void CWizardMachineApp::ExitApp()
|
|
{
|
|
CreateNewCache();
|
|
}
|
|
|
|
FILE* CWizardMachineApp::OpenAFile(CString outputFile, CString mode)
|
|
{
|
|
FILE* fPtr;
|
|
|
|
if( !( fPtr = fopen( outputFile, mode ) ) )
|
|
{
|
|
CWnd myWnd;
|
|
|
|
myWnd.MessageBox("Unable to open file" + outputFile, "ERROR", MB_OK);
|
|
//fprintf(out, "--------------** TERMINATED - Can't open output file **----------------\n");
|
|
exit( 3 );
|
|
}
|
|
|
|
return fPtr;
|
|
}
|
|
|
|
void CWizardMachineApp::PrintNodeInfo(NODE* node)
|
|
{
|
|
if (node)
|
|
{
|
|
fprintf(out, "Node name : " + node->localVars->pageName + "\n\n");
|
|
fprintf(out, "Number of Sub pages : %d\n", node->numChildNodes);
|
|
fprintf(out, "Number of Widgets : %d\n", node->numWidgets);
|
|
|
|
/**
|
|
for (int i=0; i< node->numWidgets; i++)
|
|
{
|
|
fprintf(out, "Widget%d Name : " + node->pageWidgets[i]->name + "\n", i+1);
|
|
fprintf(out, "Widget%d Value : " + node->pageWidgets[i]->value + "\n", i+1);
|
|
|
|
}
|
|
**/
|
|
fprintf(out, "-----------------------------------------------------------\n");
|
|
}
|
|
}
|
|
|
|
void CWizardMachineApp::CheckIniFileExistence(CString file)
|
|
{
|
|
FILE *f;
|
|
//BOOL CheckIniFileExistence = FALSE;
|
|
|
|
if (! (f = fopen(file, "r") ))
|
|
{
|
|
CWnd myWnd;
|
|
CString message = "File " + file + " could not be opened ";
|
|
|
|
myWnd.MessageBox(message, "ERROR", MB_OK);
|
|
fprintf(out, "------------** TERMINATED - Missing File : " + file + " **----------------\n");
|
|
exit(4);
|
|
}
|
|
else
|
|
{
|
|
fclose(f);
|
|
}
|
|
}
|
|
|
|
BOOL CWizardMachineApp::FileExists(CString file)
|
|
{
|
|
FILE *f;
|
|
|
|
if (! (f = fopen(file, "r") ))
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
void CWizardMachineApp::FillGlobalWidgetArray()
|
|
{
|
|
char buffer[MAX_SIZE] = {'\0'};
|
|
char name[MAX_SIZE] = {'\0'};
|
|
char value[MAX_SIZE] = {'\0'};
|
|
|
|
/**
|
|
char filePath[MAX_SIZE] = {'\0'};
|
|
strcpy(filePath, (char *)(LPCTSTR) customizationPath);
|
|
strcat(filePath, selCust);
|
|
strcat(filePath, "\\");
|
|
strcat(filePath, (char *)(LPCTSTR) CacheFile);
|
|
|
|
globs = OpenAFile(CString(filePath), "r");
|
|
**/
|
|
|
|
while(!feof(globs))
|
|
{
|
|
while(fgets(buffer, MAX_SIZE, globs))
|
|
{
|
|
if (strstr(buffer, "="))
|
|
{
|
|
GlobalWidgetArray[GlobalArrayIndex].name = CString(strtok(buffer,"="));
|
|
GlobalWidgetArray[GlobalArrayIndex].value = CString(strtok(NULL,"="));
|
|
|
|
//int newLineIndex = GlobalWidgetArray[GlobalArrayIndex].value.ReverseFind('\n');
|
|
|
|
//if (newLineIndex > -1)
|
|
//GlobalWidgetArray[GlobalArrayIndex].value.SetAt(newLineIndex, '\0');
|
|
|
|
GlobalWidgetArray[GlobalArrayIndex].value.TrimRight();
|
|
|
|
GlobalWidgetArray[GlobalArrayIndex].cached = TRUE;
|
|
|
|
GlobalArrayIndex++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CWizardMachineApp::CreateNewCache()
|
|
{
|
|
globs = OpenAFile(Path+CacheFile, "w");
|
|
|
|
for(int i=0; i< GlobalArrayIndex; i++)
|
|
{
|
|
if (GlobalWidgetArray[i].type != "RadioButton"
|
|
&& GlobalWidgetArray[i].type != "Text"
|
|
&& GlobalWidgetArray[i].type != "Button"
|
|
&& GlobalWidgetArray[i].type != "GroupBox" )
|
|
{
|
|
if (GlobalWidgetArray[i].name != "")
|
|
{
|
|
fprintf(globs, GlobalWidgetArray[i].name + "=" + GlobalWidgetArray[i].value);
|
|
fprintf(globs, "\n");
|
|
}
|
|
}
|
|
}
|
|
fclose(globs);
|
|
}
|
|
|
|
BOOL CWizardMachineApp::IsLastNode(NODE* treeNode)
|
|
{
|
|
|
|
NODE* tmpParent;
|
|
BOOL lastNode = TRUE;
|
|
|
|
if (treeNode)
|
|
{
|
|
tmpParent = treeNode->parent;
|
|
|
|
while(tmpParent->localVars->pageName != "Globals")
|
|
{
|
|
if (tmpParent->numChildNodes == (tmpParent->currNodeIndex+1))
|
|
tmpParent = tmpParent->parent;
|
|
else
|
|
{
|
|
lastNode = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lastNode = FALSE;
|
|
}
|
|
return lastNode;
|
|
}
|
|
|
|
BOOL CWizardMachineApp::IsFirstNode(NODE* treeNode)
|
|
{
|
|
|
|
NODE* tmpParent;
|
|
NODE* tmpNode;
|
|
BOOL firstNode = TRUE;
|
|
|
|
tmpNode = treeNode;
|
|
tmpParent = treeNode->parent;
|
|
|
|
if (tmpParent->childNodes[0] == tmpNode)
|
|
{
|
|
while((tmpParent->localVars->pageName != "Globals"))
|
|
{
|
|
tmpNode = tmpParent;
|
|
tmpParent = tmpParent->parent;
|
|
|
|
if (!(tmpParent->childNodes[0] == tmpNode))
|
|
{
|
|
firstNode = FALSE;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
firstNode = FALSE;
|
|
}
|
|
return firstNode;
|
|
}
|
|
|
|
CString CWizardMachineApp::GetModulePath()
|
|
{
|
|
char currPath[MID_SIZE];
|
|
int i,numBytes;
|
|
|
|
// Get the path of the file that was executed
|
|
numBytes = GetModuleFileName(m_hInstance, currPath, MIN_SIZE);
|
|
|
|
// get the cmd path
|
|
// Remove the filename from the path
|
|
for (i=numBytes-1;i >= 0 && currPath[i] != '\\';i--);
|
|
// Terminate command line with 0
|
|
if (i >= 0)
|
|
currPath[i+1]= '\0';
|
|
|
|
return CString(currPath);
|
|
}
|
|
|
|
CString CWizardMachineApp::GetGlobal(CString theName)
|
|
{
|
|
for (int i = 0; i <= GlobalArrayIndex; i++)
|
|
{
|
|
if (GlobalWidgetArray[i].name == theName) {
|
|
return GlobalWidgetArray[i].value;
|
|
}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
CString CWizardMachineApp::GetGlobalOptions(CString theName)
|
|
{
|
|
CString temp="";
|
|
|
|
for (int i = 0; i <= GlobalArrayIndex; i++)
|
|
{
|
|
if (GlobalWidgetArray[i].name == theName) {
|
|
if (GlobalWidgetArray[i].numOfOptions > 0) {
|
|
for (int j = 0; j < GlobalWidgetArray[i].numOfOptions; j++) {
|
|
strcat((char*)(LPCTSTR)(temp), GlobalWidgetArray[i].options.value[j]);
|
|
strcat((char*)(LPCTSTR)(temp), ";");
|
|
}
|
|
}
|
|
else {
|
|
temp = GlobalWidgetArray[i].items;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return temp;
|
|
}
|
|
|
|
BOOL CWizardMachineApp::SetGlobal(CString theName, CString theValue)
|
|
{
|
|
for (int i = 0; i <= GlobalArrayIndex; i++)
|
|
{
|
|
if (GlobalWidgetArray[i].name == theName) {
|
|
GlobalWidgetArray[i].value = theValue;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
WIDGET* CWizardMachineApp::findWidget(char *theName)
|
|
{
|
|
|
|
for (int i = 0; i <= GlobalArrayIndex; i++)
|
|
{
|
|
if (GlobalWidgetArray[i].name == theName) {
|
|
return (&GlobalWidgetArray[i]);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void CWizardMachineApp::BuildWidget(WIDGET* aWidget, CString iniSection, CString iniFile, int pageBaseIndex, BOOL readValue)
|
|
{
|
|
static int idCounter = 0;
|
|
char buffer[MAX_SIZE] = {'\0'};
|
|
char largeBuffer[EXTD_MAX_SIZE] = {'\0'};
|
|
|
|
idCounter++;
|
|
|
|
GetPrivateProfileString(iniSection, "Name", "", buffer, MAX_SIZE, iniFile);
|
|
aWidget->name = buffer;
|
|
|
|
GetPrivateProfileString(iniSection, "Type", "", buffer, MAX_SIZE, iniFile);
|
|
aWidget->type = buffer;
|
|
|
|
GetPrivateProfileString(iniSection, "Options", "", buffer, MAX_SIZE, iniFile);
|
|
aWidget->items = buffer;
|
|
|
|
if (readValue)
|
|
{
|
|
GetPrivateProfileString(iniSection, "Value", "", largeBuffer, EXTD_MAX_SIZE, iniFile);
|
|
aWidget->value = largeBuffer;
|
|
aWidget->value.TrimRight();
|
|
}
|
|
|
|
GetPrivateProfileString(iniSection, "Title", "", buffer, MAX_SIZE, iniFile);
|
|
aWidget->title = buffer;
|
|
|
|
GetPrivateProfileString(iniSection, "Group", "", buffer, MAX_SIZE, iniFile);
|
|
aWidget->group = buffer;
|
|
|
|
GetPrivateProfileString(iniSection, "Target", "", buffer, MAX_SIZE, iniFile);
|
|
aWidget->target = buffer;
|
|
|
|
GetPrivateProfileString(iniSection, "Start_x", "", buffer, MAX_SIZE, iniFile);
|
|
aWidget->location.x = atoi(buffer);
|
|
|
|
GetPrivateProfileString(iniSection, "Start_y", "", buffer, MAX_SIZE, iniFile);
|
|
aWidget->location.y = atoi(buffer);
|
|
|
|
//aWidget->size = new DIMENSION;
|
|
GetPrivateProfileString(iniSection, "Width", "", buffer, MAX_SIZE, iniFile);
|
|
aWidget->size.width = atoi(buffer);
|
|
GetPrivateProfileString(iniSection, "Height", "", buffer, MAX_SIZE, iniFile);
|
|
aWidget->size.height = atoi(buffer);
|
|
|
|
GetPrivateProfileString(iniSection, "dll", "", buffer, MAX_SIZE, iniFile);
|
|
aWidget->action.dll = buffer;
|
|
GetPrivateProfileString(iniSection, "function", "", buffer, MAX_SIZE, iniFile);
|
|
aWidget->action.function = buffer;
|
|
GetPrivateProfileString(iniSection, "parameters", "", buffer, MAX_SIZE, iniFile);
|
|
strcpy(aWidget->action.parameters, buffer);
|
|
|
|
/// Dynamic ID allocation
|
|
aWidget->widgetID = pageBaseIndex + idCounter;
|
|
|
|
|
|
// As the number of entries in the subsection are not known, a generic loop
|
|
// has been created to read all existing name/value pairs in the subsection
|
|
// and store them in the options component of the control.
|
|
GetPrivateProfileString(iniSection, "subsection", "", buffer, MAX_SIZE, iniFile);
|
|
if (strcmp(buffer, "") != 0) {
|
|
char* subSection;
|
|
subSection = new char[sizeof(buffer)];
|
|
strcpy(subSection, buffer);
|
|
|
|
if (aWidget->action.function == "")
|
|
{
|
|
int counter = 0;
|
|
int i = 0;
|
|
char* ComponentKey;
|
|
char ComponentKeyBuffer[MAX_SIZE];
|
|
if (GetPrivateProfileString(subSection, NULL, "", buffer, MAX_SIZE, iniFile) > 0)
|
|
{
|
|
while (buffer[i] != 0)
|
|
{
|
|
ComponentKey = &buffer[i];
|
|
if (GetPrivateProfileString(subSection, ComponentKey, "", ComponentKeyBuffer, MAX_SIZE, iniFile) > 0)
|
|
{
|
|
aWidget->options.name[counter] = new char[sizeof(ComponentKey)];
|
|
strcpy(aWidget->options.name[counter],ComponentKey);
|
|
aWidget->options.value[counter] = new char[sizeof(ComponentKeyBuffer)];
|
|
strcpy(aWidget->options.value[counter],ComponentKeyBuffer);
|
|
counter++;
|
|
}
|
|
while (buffer[i] != 0)
|
|
i++;
|
|
i++;
|
|
}
|
|
}
|
|
aWidget->numOfOptions = counter;
|
|
}
|
|
else {
|
|
aWidget->numOfOptions = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CWizardMachineApp::GenerateList(CString action, WIDGET* targetWidget, CString parentDirPath)
|
|
{
|
|
WIDGET* curWidget = targetWidget;
|
|
|
|
CFileFind fileList;
|
|
BOOL dirFound = fileList.FindFile(CString(currDirPath) + parentDirPath);
|
|
|
|
if(curWidget->type == "ListBox")
|
|
{
|
|
((CListBox*)curWidget->control)->ResetContent();
|
|
}
|
|
|
|
if(curWidget->type == "ComboBox")
|
|
{
|
|
((CComboBox*)curWidget->control)->ResetContent();
|
|
}
|
|
|
|
|
|
while (dirFound)
|
|
{
|
|
dirFound = fileList.FindNextFile();
|
|
|
|
if (action == "GenerateFileList")
|
|
{
|
|
if (!fileList.IsDirectory()) // skip if this is a dir
|
|
{
|
|
CString tmpFile = fileList.GetFileName();
|
|
if(curWidget->type == "ListBox")
|
|
{
|
|
((CListBox*)curWidget->control)->AddString(tmpFile);
|
|
}
|
|
|
|
if(curWidget->type == "ComboBox")
|
|
{
|
|
((CComboBox*)curWidget->control)->AddString(tmpFile);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (action == "GenerateDirList")
|
|
{
|
|
if (fileList.IsDirectory()) // skip if this is a dir
|
|
{
|
|
CString tmpFile = fileList.GetFileName();
|
|
if (!(tmpFile == "." || tmpFile == "..")) {
|
|
if(curWidget->type == "ListBox")
|
|
{
|
|
((CListBox*)curWidget->control)->AddString(tmpFile);
|
|
}
|
|
|
|
if(curWidget->type == "ComboBox")
|
|
{
|
|
((CComboBox*)curWidget->control)->AddString(tmpFile);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
fileList.Close();
|
|
}
|
|
|
|
|