public PropertiesForm(ProfilerProjectMode mode)
		{
			//
			// Required for Windows Form Designer support
			//
			InitializeComponent();

			//
			// TODO: Add any constructor code after InitializeComponent call
			//
			projectMode = ProfilerProjectMode.CreateProject;

			project = new ProjectInfo( ProjectType.File );
			this.Mode = mode;
			if (mode == ProfilerProjectMode.CreateProject)
			{
				List<string> files=SerializationHandler.GetRecentlyUsed();
				foreach (string file in files.GetRange(0,Math.Min(files.Count,5)))
				{
					LinkLabel label=new LinkLabel();
					label.AutoSize = true;
					label.Text=file;
					label.Click += delegate
					{
						ProfilerForm.form.Project = SerializationHandler.OpenProjectInfo(label.Text);
						Close();
					};
					recentProjects.Controls.Add(label);

				}
			}
		}

 public ProjectMetadata(ProjectInfo projectInfo)
 {
     if (projectInfo == null)
         throw new ArgumentNullException("projectInfo");
     m_projectInfo = projectInfo;
     Init();
 }

 public ProjectInfo GetProjectInfo()
 {
     var referenceProjectItems =
         from item in m_project.Items
         where item is ReferenceProjectItem
         select item as ReferenceProjectItem;
     var references =
         new List<ProjectReference>(referenceProjectItems.Count());
     referenceProjectItems.
         ForEach(item => references.Add(
             new ProjectReference
             {
                 Aliases = item.Aliases,
                 Name = item.Name,
                 Location = item.FileName,
                 Version = item.Version,
                 Culture = item.Culture,
                 PublicKeyToken = item.PublicKeyToken
             }));
     var projectInfo = new ProjectInfo
     {
         Name = m_project.Name,
         Configuration = m_project.ActiveConfiguration,
         Platform = m_project.ActivePlatform,
         OutputAssemblyPath = m_project.OutputAssemblyFullPath,
         Type = Guid.Parse(m_project.TypeGuid),
         References = references
     };
     return projectInfo;
 }

 private IList<ProjectReference> CreateUnusedReferencesList(ProjectInfo projectInfo)
 {
     var references =
         from item in projectInfo.References
         where !item.Name.Equals(MsCorLib, StringComparison.InvariantCultureIgnoreCase) &&
             !item.Name.Equals(SystemCore, StringComparison.InvariantCultureIgnoreCase)
         select item;
     return references.ToList();
 }

		public ProjectProvider (ProjectInfo pinfo) : base (null) {
			AddTarget ("name", pinfo.Name);
			AddTarget ("version", pinfo.Version);
			AddTarget ("compat_code", pinfo.CompatCode);

			// Alias to line up better with how it's declared
			// in the buildfile. (Need the underscore version so
			// we can reference it in .bundles)

			AddTarget ("compat-code", pinfo.CompatCode);
		}

 public static ProjectAssemblyResolver Create(ProjectInfo projectInfo)
 {
     if (projectInfo == null)
         throw new ArgumentNullException("projectInfo");
     var assemblyResolver = new ProjectAssemblyResolver(projectInfo);
     assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(projectInfo.OutputAssemblyPath));
     //assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
     foreach (var path in GetLocations(projectInfo.References))
     {
         assemblyResolver.AddSearchDirectory(path);
     }
     return assemblyResolver;
 }

        public void ProjectInfo_Serialization_InvalidFileName()
        {
            // 0. Setup
            ProjectInfo pi = new ProjectInfo();

            // 1a. Missing file name - save
            AssertException.Expects<ArgumentNullException>(() => pi.Save(null));
            AssertException.Expects<ArgumentNullException>(() => pi.Save(string.Empty));
            AssertException.Expects<ArgumentNullException>(() => pi.Save("\r\t "));

            // 1b. Missing file name - load
            AssertException.Expects<ArgumentNullException>(() => ProjectInfo.Load(null));
            AssertException.Expects<ArgumentNullException>(() => ProjectInfo.Load(string.Empty));
            AssertException.Expects<ArgumentNullException>(() => ProjectInfo.Load("\r\t "));
        }

 public static UnusedReferencesAudit Create(ProjectInfo projectInfo)
 {
     if (projectInfo == null)
         throw new ArgumentNullException("projectInfo");
     switch (projectInfo.Type.ToString("D"))
     {
         case CSharpProjectTypeString:
             return new CSharpProjectAudit(projectInfo);
         case VBasicProjectTypeString:
             return new VBasicProjectAudit(projectInfo);
         case CppCliProjectTypeString:
             return new CppCliProjectAudit(projectInfo);
         default:
             throw new NotImplementedException();
     }
 }

 public static List<ProjectInfo> getValue(string sql)
 {
     List<ProjectInfo> list = new List<ProjectInfo>();
     OleDbDataReader odr = DBHelper.GetReader(sql);
     while (odr.Read())
     {
         ProjectInfo pi = new ProjectInfo();
         pi.ProjectID = Convert.ToInt32(odr["ProjectID"]);
         pi.ProjectName = odr["ProjectName"].ToString();
         pi.Province = odr["Province"].ToString();
         pi.Remarks = odr["remarks"].ToString();
         list.Add(pi);
     }
     odr.Close();
     return list;
 }

        public NemerleContainedLanguage(IVsTextBufferCoordinator bufferCoordinator, NemerleIntellisenseProvider intellisenseProject, uint itemId, IVsHierarchy pHierarchy)
        {
            if (null == bufferCoordinator)
            {
                throw new ArgumentNullException("bufferCoordinator");
            }
            if (null == intellisenseProject)
            {
                throw new ArgumentNullException("intellisenseProject");
            }
            _hierarchy = pHierarchy;

            object projectItem = null;
            pHierarchy.GetProperty(itemId, (int)__VSHPROPID.VSHPROPID_ExtObject, out projectItem);

            _projectItem = projectItem as EnvDTE.ProjectItem;

            EnvDTE.Property prop = _projectItem.Properties.Item("FullPath");
            if (prop != null)
                _filePath = prop.Value as string;

            var project = _projectItem.ContainingProject as NemerleOAProject;
            if(project != null)
            {
                _projectInfo = ((NemerleProjectNode)project.Project).ProjectInfo;
            }

            _typeResolutionService = null;
            DynamicTypeService typeService = LanguageService.GetService(typeof(DynamicTypeService)) as DynamicTypeService;
            if (typeService != null)
                _typeResolutionService = typeService.GetTypeResolutionService(this._hierarchy);

            this.bufferCoordinator = bufferCoordinator;
            this.intellisenseProject = intellisenseProject;
            this.itemId = itemId;

            // Make sure that the secondary buffer uses the IronPython language service.
            IVsTextLines buffer;
            ErrorHandler.ThrowOnFailure(bufferCoordinator.GetSecondaryBuffer(out buffer));

            Guid languageGuid;
            this.GetLanguageServiceID(out languageGuid);
            ErrorHandler.ThrowOnFailure(buffer.SetLanguageServiceID(ref languageGuid));

            _documentClosingEventHandler = new _dispDocumentEvents_DocumentClosingEventHandler(OnDocumentClosing);
        }

        public void ProjectInfo_Serialization_SaveAndReload()
        {
            // 0. Setup
            string testFolder = TestUtils.CreateTestSpecificFolder(this.TestContext);

            Guid projectGuid = Guid.NewGuid();

            ProjectInfo originalProjectInfo = new ProjectInfo();
            originalProjectInfo.FullPath = "c:\\fullPath\\project.proj";
            originalProjectInfo.ProjectLanguage = "a language";
            originalProjectInfo.ProjectType = ProjectType.Product;
            originalProjectInfo.ProjectGuid = projectGuid;
            originalProjectInfo.ProjectName = "MyProject";

            string fileName = Path.Combine(testFolder, "ProjectInfo1.xml");

            SaveAndReloadProjectInfo(originalProjectInfo, fileName);
        }

        public static void Open(ProjectInfo project)
        {
            foreach (var view in IdeApp.Workbench.Documents)
            {
                var sourceDoc = view.GetContent<SourceControlExplorerView>();
                if (sourceDoc != null)
                {
                    sourceDoc.Load(project.Collection);
                    sourceDoc.ExpandPath(VersionControlPath.RootFolder + project.Name);
                    view.Window.SelectWindow();
                    return;
                }
            }

            var sourceControlExplorerView = new SourceControlExplorerView();
            sourceControlExplorerView.Load(project.Collection);
            sourceControlExplorerView.ExpandPath(VersionControlPath.RootFolder + project.Name);
            IdeApp.Workbench.OpenDocument(sourceControlExplorerView, true);
        }

			public override object GetResult(out int level)
			{
				level = 1;
				ProjectInfo project = new ProjectInfo();
				NProf.form.Project = project;
				Profiler profiler = new Profiler();
				//project.ApplicationName = @"D:\Meta\0.2\bin\Debug\Meta.exe";
				//project.Arguments = "-test";
				project.ApplicationName = Path.Combine(NProfDirectory, @"TestProfilee\bin\Debug\TestProfilee.exe");

				run = project.CreateRun(profiler);
				run.profiler.Completed += new EventHandler(profiler_Completed);
				run.Start();

				while (result == null)
				{
					Thread.Sleep(100);
				}
				return result;
			}

        public ActionResult AddProject( [DataSourceRequest] DataSourceRequest request,ProjectInfoModel model)
        {
            ProjectInfo project = new ProjectInfo();
            var getSatusId = _projects.GetstatusName(model.StatusName);
            if(ModelState.IsValid)
            {
                project.Id = model.Id;
                project.PM = model.PM;
                project.Project = model.Project;
                project.ProjectComment = model.ProjectComment;
                project.statusId = getSatusId.Id;
                project.percentage = model.percentage;
                _projects.CreateProjects(project);
                TempData["success"] = "Edited Succefully";
            }
            else
            {
                TempData["fail"] = " Not Edited Succefully";
            }

            return RedirectToAction("ProjectOnDisplay", "AdminProject");
        }

        public NemerleErrorTask(ProjectInfo projectInfo, CompilerMessage compilerMessage)
        {
            ErrorHelper.ThrowIsNull(projectInfo,     "projectInfo");
            ErrorHelper.ThrowIsNull(compilerMessage, "compilerMessage");

            ProjectInfo     = projectInfo;
            CompilerMessage = compilerMessage;

            var loc = compilerMessage.Location;

            if (loc.FileIndex != 0)
            {
                var span = Utils.SpanFromLocation(loc);
                Document = loc.File;
                Line     = span.iStartLine;
                Column   = span.iStartIndex;
            }

            Text = compilerMessage.Msg;

            switch (compilerMessage.Kind)
            {
                case MessageKind.Error:
                    Priority = TaskPriority.High;
                    ErrorCategory = TaskErrorCategory.Error;
                    break;
                case MessageKind.Warning:
                    Priority = TaskPriority.Normal;
                    ErrorCategory = TaskErrorCategory.Warning;
                    break;
                default:
                    Priority = TaskPriority.Low;
                    ErrorCategory = TaskErrorCategory.Message;
                    break;
            }

            Category = TaskCategory.BuildCompile;
            HierarchyItem = projectInfo.ProjectNode.InteropSafeHierarchy;
        }

        public void ProjectInfo_Serialization_AnalysisResults()
        {
            // 0. Setup
            string testFolder = TestUtils.CreateTestSpecificFolder(this.TestContext);

            Guid projectGuid = Guid.NewGuid();

            ProjectInfo originalProjectInfo = new ProjectInfo();
            originalProjectInfo.ProjectGuid = projectGuid;

            // 1. Null list
            SaveAndReloadProjectInfo(originalProjectInfo, Path.Combine(testFolder, "ProjectInfo_AnalysisResults1.xml"));

            // 2. Empty list
            originalProjectInfo.AnalysisResults = new List<AnalysisResult>();
            SaveAndReloadProjectInfo(originalProjectInfo, Path.Combine(testFolder, "ProjectInfo_AnalysisResults2.xml"));

            // 3. Non-empty list
            originalProjectInfo.AnalysisResults.Add(new AnalysisResult() { Id = string.Empty, Location = string.Empty }); // empty item
            originalProjectInfo.AnalysisResults.Add(new AnalysisResult() { Id = "Id1", Location = "location1" });
            originalProjectInfo.AnalysisResults.Add(new AnalysisResult() { Id = "Id2", Location = "location2" });
            SaveAndReloadProjectInfo(originalProjectInfo, Path.Combine(testFolder, "ProjectInfo_AnalysisResults3.xml"));
        }

    /// <summary>
    /// Load data.
    /// </summary>
    public void LoadData()
    {
        process = true;
        if (!Visible || StopProcessing)
        {
            EnableViewState = false;
            process = false;
        }

        IsLiveSite = false;

        if (ProjectID > 0)
        {
            // Get information on current project
            project = ProjectInfoProvider.GetProjectInfo(ProjectID);
        }

        // Get project resource
        resProjects = ResourceInfoProvider.GetResourceInfo("CMS.ProjectManagement");

        if ((resProjects != null) && (project != null))
        {
            QueryDataParameters parameters = new QueryDataParameters();
            parameters.Add("@ID", resProjects.ResourceId);
            parameters.Add("@ProjectID", project.ProjectID);
            parameters.Add("@SiteID", CMSContext.CurrentSiteID);

            string where = "";
            int groupId = project.ProjectGroupID;

            // Build where condition
            if (groupId > 0)
            {
                where = "RoleGroupID=" + groupId.ToString() + " AND PermissionDisplayInMatrix = 0";
            }
            else
            {
                where = "RoleGroupID IS NULL AND PermissionDisplayInMatrix = 0";
            }

            // Setup matrix control
            gridMatrix.IsLiveSite = IsLiveSite;
            gridMatrix.QueryParameters = parameters;
            gridMatrix.WhereCondition = where;
            gridMatrix.ContentBefore = "<table class=\"PermissionMatrix\" cellspacing=\"0\" cellpadding=\"0\" rules=\"rows\" border=\"1\" style=\"border-collapse:collapse;\">";
            gridMatrix.ContentAfter = "</table>";
        }
    }

    /// <summary>
    /// Saves control with actual data.
    /// </summary>
    public bool Save()
    {
        if (!CheckPermissions("CMS.ProjectManagement", PERMISSION_MANAGE))
        {
            return false;
        }

        // Validate the form
        if (Validate())
        {
            // Indicates whether project is new
            bool isNew = false;

            int progress = 0;

            // Ensure the info object
            if (ProjectObj == null)
            {
                // New project

                ProjectInfo pi = new ProjectInfo();
                // First initialization of the Access property - allow authenticated users
                pi.ProjectAccess = 1222;
                pi.ProjectCreatedByID = CMSContext.CurrentUser.UserID;

                pi.ProjectOwner = 0;

                if (CommunityGroupID != 0)
                {
                    pi.ProjectGroupID = CommunityGroupID;
                    // Set default access to the group
                    pi.ProjectAccess = 3333;
                }

                mProjectObj = pi;
                isNew = true;
            }
            else
            {
                // Existing project

                // Reset ProjectOrder if checkbox was unchecked
                if ((ProjectObj.ProjectAllowOrdering)
                    && (!chkProjectAllowOrdering.Checked))
                {
                    ProjectInfoProvider.ResetProjectOrder(ProjectObj.ProjectID);
                }

                // Clear the hashtables if the codename has been changed
                if ((ProjectObj.ProjectGroupID > 0)
                    && ProjectObj.ProjectName != txtProjectName.Text)
                {
                    ProjectInfoProvider.Clear(true);
                }

                progress = ProjectInfoProvider.GetProjectProgress(ProjectObj.ProjectID);
            }

            ltrProjectProgress.Text = ProjectTaskInfoProvider.GenerateProgressHtml(progress, true);

            // Initialize object
            ProjectObj.ProjectSiteID = CMSContext.CurrentSiteID;

            if (DisplayMode == ControlDisplayModeEnum.Simple)
            {
                if (isNew)
                {
                    ProjectObj.ProjectName = ValidationHelper.GetCodeName(txtProjectDisplayName.Text, 50) + ((CommunityGroupID > 0) ? "_group_" : "_general_") + CodenameGUID;
                }
            }
            else
            {
                ProjectObj.ProjectName = txtProjectName.Text.Trim();
            }
            ProjectObj.ProjectDisplayName = txtProjectDisplayName.Text.Trim();
            ProjectObj.ProjectDescription = txtProjectDescription.Text.Trim();
            ProjectObj.ProjectStartDate = dtpProjectStartDate.SelectedDateTime;
            ProjectObj.ProjectDeadline = dtpProjectDeadline.SelectedDateTime;
            ProjectObj.ProjectOwner = ValidationHelper.GetInteger(userSelector.UniSelector.Value, 0);
            ProjectObj.ProjectStatusID = ValidationHelper.GetInteger(drpProjectStatus.SelectedValue, 0);
            ProjectObj.ProjectAllowOrdering = chkProjectAllowOrdering.Checked;

            // Set ProjectNodeID
            if (!ShowPageSelector)
            {
                // Set current node id for new project
                if (isNew && (CMSContext.CurrentDocument != null))
                {
                    ProjectObj.ProjectNodeID = CMSContext.CurrentDocument.NodeID;
                }
            }
            else
            {
                TreeProvider treeProvider = new TreeProvider();
                TreeNode node = treeProvider.SelectSingleNode(ValidationHelper.GetGuid(pageSelector.Value, Guid.Empty), TreeProvider.ALL_CULTURES, CMSContext.CurrentSiteName);
                if (node != null)
                {
//.........这里部分代码省略.........

        /// <summary>
        /// Creates the IfcPostalAddress, and assigns it to the file.
        /// </summary>
        /// <param name="file">The IFC file.</param>
        /// <param name="address">The address string.</param>
        /// <param name="town">The town string.</param>
        /// <returns>The handle of IFC file.</returns>
        private IFCAnyHandle CreateIFCAddress(IFCFile file, Document document, ProjectInfo projInfo)
        {
            IFCAnyHandle postalAddress = null;
            postalAddress = CreateIFCAddressFromExtStorage(file, document);
            if (postalAddress != null)
                return postalAddress;

            string projectAddress = projInfo != null ? projInfo.Address : String.Empty;
            SiteLocation siteLoc = document.ActiveProjectLocation.SiteLocation;
            string location = siteLoc != null ? siteLoc.PlaceName : String.Empty;

            if (projectAddress == null)
                projectAddress = String.Empty;
            if (location == null)
                location = String.Empty;

            List<string> parsedAddress = new List<string>();
            string city = String.Empty;
            string state = String.Empty;
            string postCode = String.Empty;
            string country = String.Empty;

            string parsedTown = location;
            int commaLoc = -1;
            do
            {
                commaLoc = parsedTown.IndexOf(',');
                if (commaLoc >= 0)
                {
                    if (commaLoc > 0)
                        parsedAddress.Add(parsedTown.Substring(0, commaLoc));
                    parsedTown = parsedTown.Substring(commaLoc + 1).TrimStart(' ');
                }
                else if (!String.IsNullOrEmpty(parsedTown))
                    parsedAddress.Add(parsedTown);
            } while (commaLoc >= 0);

            int numLines = parsedAddress.Count;
            if (numLines > 0)
            {
                country = parsedAddress[numLines - 1];
                numLines--;
            }

            if (numLines > 0)
            {
                int spaceLoc = parsedAddress[numLines - 1].IndexOf(' ');
                if (spaceLoc > 0)
                {
                    state = parsedAddress[numLines - 1].Substring(0, spaceLoc);
                    postCode = parsedAddress[numLines - 1].Substring(spaceLoc + 1);
                }
                else
                    state = parsedAddress[numLines - 1];
                numLines--;
            }

            if (numLines > 0)
            {
                city = parsedAddress[numLines - 1];
                numLines--;
            }

            List<string> addressLines = new List<string>();
            if (!String.IsNullOrEmpty(projectAddress))
                addressLines.Add(projectAddress);

            for (int ii = 0; ii < numLines; ii++)
            {
                addressLines.Add(parsedAddress[ii]);
            }

            postalAddress = IFCInstanceExporter.CreatePostalAddress(file, null, null, null,
               null, addressLines, null, city, state, postCode, country);

            return postalAddress;
        }

        static void DumpNetModule(ProjectInfo info, List<ProjectInfo> projectFiles)
        {
            var fileName = info.AssemblyFileName;
            if (string.IsNullOrEmpty(fileName))
                throw new Exception(".NET module filename is empty or null");

            var asmList = new AssemblyList("dnspc.exe", false);
            asmList.UseGAC = !noGac;
            asmList.AddSearchPath(Path.GetDirectoryName(fileName));
            foreach (var path in asmPaths)
                asmList.AddSearchPath(path);
            var lasm = new LoadedAssembly(asmList, fileName);
            var opts = new DecompilationOptions {
                FullDecompilation = true,
                CancellationToken = new CancellationToken(),
            };

            TextWriter writer = null;
            try {
                var lang = GetLanguage();

                if (useStdout)
                    writer = System.Console.Out;
                else {
                    var baseDir = GetProjectDir(lang, fileName);
                    Directory.CreateDirectory(baseDir);
                    writer = new StreamWriter(info.ProjectFileName, false, Encoding.UTF8);
                    opts.SaveAsProjectDirectory = baseDir;
                    opts.DontReferenceStdLib = noCorlibRef;
                    opts.ProjectFiles = projectFiles;
                    opts.ProjectGuid = info.ProjectGuid;
                    opts.DontShowCreateMethodBodyExceptions = dontMaskErr;
                    Console.WriteLine("Saving {0} to {1}", fileName, baseDir);
                }

                lang.DecompileAssembly(lasm, new PlainTextOutput(writer), opts);
            }
            finally {
                if (!useStdout && writer != null)
                    writer.Dispose();
            }
        }