WTL Wizard for Visual Studio .NET

function fechaHoy()
{
	var fecha = new Date();
	return fecha.getDate() + "/" + ( fecha.getMonth() + 1 ) + "/" + fecha.getYear();
}


function OnFinish(selProj, selObj)
{
	try
	{
		var strProjectPath = wizard.FindSymbol('PROJECT_PATH');
		var strProjectName = wizard.FindSymbol('PROJECT_NAME');
		var bMDI = wizard.FindSymbol('ATL_PROJTYPE_MDI');

		wizard.AddSymbol("SAFE_PROJECT_NAME", CreateSafeName(strProjectName));
		wizard.AddSymbol("FRAME_CLASS", "CMainFrame" );
		if( bMDI )
			wizard.AddSymbol("FRAME_BASE_CLASS", "CMDIFrameWindowImpl" );
		else
			wizard.AddSymbol("FRAME_BASE_CLASS", "CFrameWindowImpl" );
		wizard.AddSymbol("ATL_CURRENT_YEAR", fechaHoy() );


		var strSafeProjectName = wizard.FindSymbol('SAFE_PROJECT_NAME');
		var strViewclass = "C" + strSafeProjectName + "AppView"

		wizard.AddSymbol("VIEW",  strSafeProjectName + "View" );
		wizard.AddSymbol("CHILD_FRAME",  "childfrm" );
		wizard.AddSymbol("CHILD_FRAME_CLASS",  "CChildFrame" );
		wizard.AddSymbol("CHILD_FRAME_BASE_CLASS",  "CMDIChildWindowImpl" );
		wizard.AddSymbol("FRAME",  "MainFrm" );
		wizard.AddSymbol("VIEW_STYLES", "WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN" );
		
		wizard.AddSymbol("VIEW_CLASS", strViewclass );
		
		var cmbValue = wizard.FindSymbol('COMBO_VIEW');
		if( cmbValue != "CWindowImpl" )
		{	
			wizard.AddSymbol('VIEW_BASE',true);
			wizard.AddSymbol('VIEW_BASE_CONTROL', cmbValue);
			if( cmbValue == "VIEWTYPE_FORM" )
			{
				wizard.AddSymbol('VIEW_BASE_CLASS', "CDialogImpl");
				wizard.AddSymbol('VIEW_BASE',false);
			}
	
			wizard.AddSymbol('VIEWTYPE_GENERIC', false);

			switch( cmbValue )
			{
				case "VIEWTYPE_FORM":
					wizard.AddSymbol('VIEWTYPE_FORM', true);
				break;
				case "CListBox":
					wizard.AddSymbol('VIEWTYPE_LISTBOX', true);
				break;
				case "CEdit":
					wizard.AddSymbol('VIEWTYPE_EDIT', true);
				break;
				case "CListViewCtrl":
					wizard.AddSymbol('VIEWTYPE_LISVIEW', true);
				break;
				case "CTreeViewCtrl":
					wizard.AddSymbol('VIEWTYPE_TREEVIEW', true);
				break;
				case "CRichEditCtrl":
					wizard.AddSymbol('VIEWTYPE_RICHEDIT', true);
				break;
				case "CAxWindow":
					wizard.AddSymbol('VIEWTYPE_DHTML_OLD', true);
				break;
			}
		}
		
		
		//SelectView();
		wizard.AddSymbol("ATL_MAINDLG_CLASS", "CMainDlg" );
		wizard.AddSymbol("ATL_MAINDLG_BASE_CLASS", "CDialogImpl" );
		selProj = CreateCustomProject(strProjectName, strProjectPath);
		AddConfig(selProj, strProjectName);
		AddFilters(selProj);
		//SetFilters(selProj);
		var InfFile = CreateCustomInfFile();
		AddFilesToCustomProj(selProj, strProjectName, strProjectPath, InfFile);
		PchSettings(selProj);
		InfFile.Delete();

		selProj.Object.Save();
	}
	catch(e)
	{
		if (e.description.length != 0)
			SetErrorInfo(e);
		return e.number
	}
}

function CreateCustomProject(strProjectName, strProjectPath)
{
	try
	{
		var strProjTemplatePath = wizard.FindSymbol('PROJECT_TEMPLATE_PATH');
		var strProjTemplate = '';
		strProjTemplate = strProjTemplatePath + '\\default.vcproj';

		var Solution = dte.Solution;
		var strSolutionName = "";
		if (wizard.FindSymbol("CLOSE_SOLUTION"))
		{
			Solution.Close();
			strSolutionName = wizard.FindSymbol("VS_SOLUTION_NAME");
			if (strSolutionName.length)
			{
				var strSolutionPath = strProjectPath.substr(0, strProjectPath.length - strProjectName.length);
				Solution.Create(strSolutionPath, strSolutionName);
			}
		}

		var strProjectNameWithExt = '';
		strProjectNameWithExt = strProjectName + '.vcproj';

		var oTarget = wizard.FindSymbol("TARGET");
		var prj;
		if (wizard.FindSymbol("WIZARD_TYPE") == vsWizardAddSubProject)  // vsWizardAddSubProject
		{
			var prjItem = oTarget.AddFromTemplate(strProjTemplate, strProjectNameWithExt);
			prj = prjItem.SubProject;
		}
		else
		{
			prj = oTarget.AddFromTemplate(strProjTemplate, strProjectPath, strProjectNameWithExt);
		}
		return prj;
	}
	catch(e)
	{
		throw e;
	}
}

function AddFilters(proj)
{
	try
	{
		// Add the folders to your project
		var strSrcFilter = wizard.FindSymbol('SOURCE_FILTER');
		var strHFilter = wizard.FindSymbol('HEADER_FILTER');
		
		var group = proj.Object.AddFilter('Source Files');
		group.Filter = strSrcFilter;
		
		var groupH = proj.Object.AddFilter('Header Files');
		groupH.Filter = strHFilter;

		var groupR = proj.Object.AddFilter('Resource Files');
		groupR.Filter = "rc;ico;rgs";

		var groupI = proj.Object.AddFilter('Image Files');
		groupI.Filter = "bmp;gif;jpeg;jpg;png";
		
	}
	catch(e)
	{
		throw e;
	}
}

function AddConfig(proj, strProjectName)
{
	try
	{
		var Conf = new Array();
		Conf[ 0 ] = new Array();
		Conf[ 1 ] = new Array();
		
		
		Conf[ 0 ][ 0 ] = 'Debug';
		Conf[ 0 ][ 1 ] = '_DEBUG';
		Conf[ 0 ][ 2 ] = "\"$(TargetPath)\" /RegServer";
		Conf[ 1 ][ 0 ] = 'Release';
		Conf[ 1 ][ 1 ] = 'NDEBUG';
		Conf[ 1 ][ 2 ] = "\"$(TargetPath)\" /RegServer";
		
		var i;
		
		for( i = 0; i < 2; i++ )
		{
			var config = proj.Object.Configurations(Conf[ i ][ 0 ]);
			config.IntermediateDirectory = Conf[ i ][ 0 ];
			config.OutputDirectory = Conf[ i ][ 0 ];

			var CLTool = config.Tools('VCCLCompilerTool');
			var CLTool = config.Tools("VCCLCompilerTool");
			CLTool.UsePrecompiledHeader = pchGenerateAuto;
			CLTool.WarningLevel = warningLevel_3;
			CLTool.Detect64BitPortabilityProblems = true;
			
			var bDebug = Conf[ i ][ 0 ] == 'Debug';
			
			if( bDebug )
			{
				CLTool.MinimalRebuild = true;
				CLTool.DebugInformationFormat = debugEditAndContinue;
				CLTool.BasicRuntimeChecks = runtimeBasicCheckAll;
				CLTool.Optimization = optimizeDisabled;
				CLTool.PreprocessorDefinitions = "WIN32,_DEBUG,_WINDOWS,STRICT";
				CLTool.RuntimeLibrary = rtMultiThreadedDebug;
			}
			else
			{
				CLTool.DebugInformationFormat = debugDisabled;
				CLTool.InlineFunctionExpansion = expandOnlyInline;
				CLTool.EnableFunctionLevelLinking = true;
				CLTool.StringPooling = true;
				CLTool.PreprocessorDefinitions = "WIN32,_WINDOWS,STRICT";
				CLTool.RuntimeLibrary = rtMultiThreaded;
			}
			
			// MIDL settings
			var strSafeProjectName = wizard.FindSymbol("SAFE_PROJECT_NAME");
			var MidlTool = config.Tools("VCMidlTool");
			MidlTool.MkTypLibCompatible = false;
			if (IsPlatformWin32(config))
				MidlTool.TargetEnvironment = midlTargetWin32;

			if (bDebug)
				MidlTool.PreprocessorDefinitions = "_DEBUG";
			else
				MidlTool.PreprocessorDefinitions = "NDEBUG";

			MidlTool.HeaderFileName = strSafeProjectName + ".h";
			MidlTool.InterfaceIdentifierFileName = strSafeProjectName + "_i.c";
			MidlTool.ProxyFileName = strSafeProjectName + "_p.c";
			MidlTool.GenerateStublessProxies = true;
			MidlTool.TypeLibraryName = "$(IntDir)/" + strSafeProjectName + ".tlb";
			MidlTool.DLLDataFileName = "";

			// Resource settings
			var RCTool = config.Tools("VCResourceCompilerTool");
			RCTool.Culture = rcEnglishUS;
			RCTool.AdditionalIncludeDirectories = "$(IntDir)";
			if (bDebug)
				RCTool.PreprocessorDefinitions = "_DEBUG";
			else
				RCTool.PreprocessorDefinitions = "NDEBUG";
			
			
			// TODO: Add linker settings
			var LinkTool = config.Tools('VCLinkerTool');
			LinkTool.SubSystem = subSystemWindows;
			LinkTool.IgnoreImportLibrary = true;
			LinkTool.TargetMachine = machineX86;

			LinkTool.OutputFile = "$(OutDir)/" + strProjectName + ".exe";

			LinkTool.ImportLibrary = "$(OutDir)/" + strProjectName + ".lib";
			
			/*if (bAttributed)
				LinkTool.MergedIDLBaseFileName = "_" + strProjectName + ".idl";*/

			if (bDebug)
			{
				LinkTool.GenerateDebugInformation = true;
				LinkTool.LinkIncremental = linkIncrementalYes;
			}
			else
			{
				LinkTool.GenerateDebugInformation = false;
				LinkTool.LinkIncremental = linkIncrementalNo;
				LinkTool.EnableCOMDATFolding = optFolding;
				LinkTool.OptimizeReferences = optReferences;
			}

			if( wizard.FindSymbol( 'CREATE_COM_SERVER' ) )
			{
				var PostBuildTool = config.Tools("VCPostBuildEventTool");
				var L_PerformingRegistration2_Text = "Performing registration";
				PostBuildTool.Description = L_PerformingRegistration2_Text;
				PostBuildTool.CommandLine = Conf[ i ][ 2 ];
			}
		}
	}
	catch(e)
	{
		throw e;
	}
}

function PchSettings(proj)
{
	// TODO: specify pch settings
}

function DelFile(fso, strWizTempFile)
{
	try
	{
		if (fso.FileExists(strWizTempFile))
		{
			var tmpFile = fso.GetFile(strWizTempFile);
			tmpFile.Delete();
		}
	}
	catch(e)
	{
		throw e;
	}
}

function CreateCustomInfFile()
{
	try
	{
		var fso, TemplatesFolder, TemplateFiles, strTemplate;
		fso = new ActiveXObject('Scripting.FileSystemObject');

		var TemporaryFolder = 2;
		var tfolder = fso.GetSpecialFolder(TemporaryFolder);
		var strTempFolder = tfolder.Drive + '\\' + tfolder.Name;

		var strWizTempFile = strTempFolder + "\\" + fso.GetTempName();

		var strTemplatePath = wizard.FindSymbol('TEMPLATES_PATH');
		var strInfFile = strTemplatePath + '\\Templates.inf';
		wizard.RenderTemplate(strInfFile, strWizTempFile);

		var WizTempFile = fso.GetFile(strWizTempFile);
		return WizTempFile;
	}
	catch(e)
	{
		throw e;
	}
}

function GetTargetName(strName, strProjectName)
{
	try
	{
		var strResPath = "res"
		var strTarget = strName;
		var strSafeProjectName = wizard.FindSymbol("SAFE_PROJECT_NAME");
		if (strName.substr(0, 4) == "root")
		{
			var strlen = strName.length;
			if (strName == "root.ico" || strName == "rootdoc.ico" )
			{
				strTarget = strResPath + "\\" + strSafeProjectName + strName.substr(4, strlen - 4);
			}
			else
			{
				strTarget = strSafeProjectName + strName.substr(4, strlen - 4);
			}
			return strTarget;
		}

		switch (strName)
		{
			case "readme.txt":
				strTarget = "ReadMe.txt";
				break;
			case "resource.h":
				strTarget = "resource.h";
				break;
			case "frame.h":
				strTarget = "MainFrm.h";
				break;
			case "stdatl.h":
				strTarget = "stdafx.h";
				break;
			case "stdatl.cpp":
				strTarget = "stdafx.cpp";
				break;
			case "view.h":
				strTarget =  strSafeProjectName + "view.h";
				break;
			case "toolbar.bmp":
				strTarget =  strResPath + "\\" + "toolbar.bmp";
				break;
			default:
				break;
		}
		return strTarget; 
	}
	catch(e)
	{
		throw e;
	}
}

function AddFilesToCustomProj(proj, strProjectName, strProjectPath, InfFile)
{
	try
	{
		var projItems = proj.ProjectItems

		var strTemplatePath = wizard.FindSymbol('TEMPLATES_PATH');

		var strTpl = '';
		var strName = '';

		var strTextStream = InfFile.OpenAsTextStream(1, -2);
		while (!strTextStream.AtEndOfStream)
		{
			strTpl = strTextStream.ReadLine();
			if (strTpl != '')
			{
				strName = strTpl;
				var strTarget = GetTargetName(strName, strProjectName);
				var strTemplate = strTemplatePath + '\\' + strTpl;
				var strFile = strProjectPath + '\\' + strTarget;

				var bCopyOnly = false;  //"true" will only copy the file from strTemplate to strTarget without rendering/adding to the project
				var strExt = String( strName.substr(strName.lastIndexOf(".")) );
				strExt.toLowerCase();
				if(strExt==".bmp" || strExt==".ico" || strExt==".gif" || strExt==".rtf" || strExt==".css")
				{
					bCopyOnly = true;
				}
				wizard.RenderTemplate(strTemplate, strFile, bCopyOnly);
				proj.Object.AddFile(strFile);
			}
		}
		strTextStream.Close();
	}
	catch(e)
	{
		throw e;
	}
}