public OvlModelSearchResult(ProjectType type, int modelsFound, int totalModels, List<string> remainingOvlModels)
{
_type = type;
_modelsFound = modelsFound;
_totalModels = totalModels;
_remainingOvlModels = remainingOvlModels;
}
public Order(
string header,
string customerName,
DateTime createdOnDateTime,
DateTime deadLine,
MailAddress email,
string description,
ISet<Uri> attachments,
ProjectType projectType)
{
Require.NotEmpty(header, nameof(header));
Require.NotEmpty(customerName, nameof(customerName));
Require.NotNull(email, nameof(email));
Require.NotNull(description, nameof(description));
Require.NotNull(attachments, nameof(attachments));
Header = header;
CustomerName = customerName;
CreatedOnDateTime = createdOnDateTime;
DeadLine = deadLine;
Email = email;
Description = description;
Attachments = attachments;
ProjectType = projectType;
}
public Project(
int projectId,
string name,
ProjectType[] projectType,
string info,
ProjectStatus projectStatus,
Common.Image landingImage,
Uri versionControlSystemUri,
Uri projectManagementSystemUri,
HashSet<Issue> issues,
HashSet<ProjectMembership> projectMemberships,
HashSet<Common.Image> screenshots)
{
Require.Positive(projectId, nameof(projectId));
Require.NotEmpty(name, nameof(name));
Require.NotNull(info, nameof(info));
Require.NotNull(versionControlSystemUri, nameof(versionControlSystemUri));
Require.NotNull(projectManagementSystemUri, nameof(projectManagementSystemUri));
ProjectId = projectId;
Name = name;
ProjectType = projectType;
Info = info;
ProjectStatus = projectStatus;
LandingImage = landingImage;
VersionControlSystemUri = versionControlSystemUri;
ProjectManagementSystemUri = projectManagementSystemUri;
Issues = issues;
ProjectMemberships = projectMemberships;
Screenshots = screenshots;
}
public static string CreateProjectFile(BootstrappedProject project, ProjectType projectType, IEnumerable<ProjectReferenceData> references = null, bool isSelfHost = false)
{
var includes = CrawlFoldersForIncludes(project.ProjectRoot);
var compileIncludesText = string.Join("", includes.Compile.ToArray());
var contentIncludesText = "";
var referencesText = "";
var selfHostReferences = isSelfHost ? Environment.NewLine + @" <Reference Include=""System.ServiceProcess"" />" : "";
var queueConfigurationReferences = isSelfHost ? Environment.NewLine + @" <Reference Include=""System.Configuration"" />" : "";
if (references != null)
{
var projectReferences = references.Select(CreateProjectReference);
referencesText = Environment.NewLine + "<ItemGroup>" + string.Join("", projectReferences.ToArray()) + Environment.NewLine + "</ItemGroup>";
}
if (includes.Content.Any())
{
contentIncludesText = Environment.NewLine + "<ItemGroup>" + string.Join("", includes.Content.ToArray()) + Environment.NewLine + "</ItemGroup>";
}
var projectFileContent =
ClassLibraryProject
.Replace("{{projectGuid}}", project.ProjectGuid.ToString())
.Replace("{{outputType}}", projectType.ToString())
.Replace("{{assemblyName}}", project.ProjectName)
.Replace("{{compileIncludes}}", compileIncludesText)
.Replace("{{contentIncludes}}", contentIncludesText)
.Replace("{{queueConfigurationReferences}}", queueConfigurationReferences)
.Replace("{{selfHostReferences}}", selfHostReferences)
.Replace("{{referenceIncludes}}", referencesText);
return projectFileContent;
}
internal static void generate(string filename, string version, string asmName, string ns, ProjectType type)
{
Project p = new Project();
string typeDesc = null;
p.Xml.DefaultTargets = "Build";
createItemGroup(p, "ProjectConfigurations");
createGlobals(ns, type, p, "Globals");
p.Xml.AddImport(@"$(VCTargetsPath)\Microsoft.Cpp.Default.props");
switch (type) {
case ProjectType.ConsoleApp: typeDesc = "Application"; break;
case ProjectType.XamlApp: typeDesc = "Application"; break;
case ProjectType.ClassLibrary: typeDesc = "DynamicLibrary"; break;
default:
throw new InvalidOperationException("unhandled projectType: " + type);
}
createCfgProp(p.Xml, typeDesc, true);
createCfgProp(p.Xml, typeDesc, false);
p.Xml.AddImport(@"$(VCTargetsPath)\Microsoft.Cpp.props");
addPropertySheetImports(p.Xml);
addPropertyGroup(p.Xml, makeCfgCondition(DEBUG, PLATFORM), new Blah2(b2));
addPropertyGroup(p.Xml, makeCfgCondition(RELEASE, PLATFORM), new Blah2(b2));
addItemDefs(p.Xml);
const string C_TARGET_RULES = @"$(VCTargetsPath)\Microsoft.Cpp.targets";
var v99 = p.Xml.CreateImportElement(C_TARGET_RULES);
p.Xml.AppendChild(v99);
p.Save(filename);
}
public ProjectInfo( ProjectType pt )
{
_po = new Options();
_strName = null;
_rc = new RunCollection( this );
_pt = pt;
}
public AdminProject(
int projectId,
string name,
ProjectType[] projectType,
string info,
ProjectStatus projectStatus,
Common.Image landingImage,
AccessLevel accessLevel,
Uri versionControlSystemUri,
Uri projectManagementSystemUri,
HashSet<Issue> issues,
HashSet<ProjectMembership> projectDevelopers,
HashSet<Common.Image> screenshots)
{
Require.Positive(projectId, nameof(projectId));
Require.NotEmpty(name, nameof(name));
Require.NotNull(info, nameof(info));
Require.NotNull(versionControlSystemUri, nameof(versionControlSystemUri));
Require.NotNull(projectManagementSystemUri, nameof(projectManagementSystemUri));
ProjectId = projectId;
Name = name;
ProjectType = projectType ?? new[] {Common.ProjectType.Other};
AccessLevel = accessLevel;
Info = info;
ProjectStatus = projectStatus;
LandingImage = landingImage;
VersionControlSystemUri = versionControlSystemUri;
ProjectManagementSystemUri = projectManagementSystemUri;
Issues = issues ?? new HashSet<Issue>();
ProjectMemberships = projectDevelopers ?? new HashSet<ProjectMembership>();
Screenshots = screenshots ?? new HashSet<Common.Image>();
}
public MainWindow(IGUIToolkit guiToolkit)
: base("LongoMatch")
{
this.Build();
this.guiToolKit = guiToolkit;
projectType = ProjectType.None;
timeline = new TimeLineWidget();
downbox.PackStart(timeline, true, true, 0);
guTimeline = new GameUnitsTimelineWidget ();
downbox.PackStart(guTimeline, true, true, 0);
player.SetLogo(System.IO.Path.Combine(Config.ImagesDir(),"background.png"));
player.LogoMode = true;
player.Tick += OnTick;
player.Detach += (sender, e) => DetachPlayer(true);
capturer.Visible = false;
capturer.Logo = System.IO.Path.Combine(Config.ImagesDir(),"background.png");
capturer.CaptureFinished += (sender, e) => {CloseCaptureProject();};
buttonswidget.Mode = TagMode.Predifined;
localPlayersList.Team = Team.LOCAL;
visitorPlayersList.Team = Team.VISITOR;
ConnectSignals();
ConnectMenuSignals();
if (!Config.useGameUnits)
GameUnitsViewAction.Visible = false;
}
public string GetAssemblyInfoText(VersionVariables vars, string rootNamespace, ProjectType projectType)
{
string assemblyInfoFormat;
if (projectType == ProjectType.CSharp)
{
assemblyInfoFormat = csharpAssemblyInfoFormat;
}
else if (projectType == ProjectType.FSharp)
{
assemblyInfoFormat = fsharpAssemblyInfoFormat;
}
else
{
throw new ArgumentException("ProjectType");
}
var v = vars.ToList();
var assemblyInfo = string.Format(
assemblyInfoFormat,
vars.AssemblySemVer,
vars.MajorMinorPatch + ".0",
vars.InformationalVersion,
GenerateStaticVariableMembers(v, projectType),
rootNamespace);
return assemblyInfo;
}
public ProjectUploadingEventArg(DomainActionData actionData, string projectId, string projectName, ProjectType projectType, ProjectSubtype projectSubtype)
: base(actionData)
{
ProjectId = projectId;
ProjectName = projectName;
ProjectType = projectType;
ProjectSubtype = projectSubtype;
}
public Project(ProjectType type, string name, Guid id, ProjectUser founder)
{
Type = type;
Name = name;
DateCreated = System.DateTime.Now;
Id = id;
Users = new Dictionary<Guid, ProjectUser>();
//Users[founder.Id] = founder;
}
public SavingStorage()
{
UsedProgram = ProjectManager.UsedProgram;
Frames = ProjectManager.CurrentProject.Frames;
IsBrightnessCalculated = ProjectManager.CurrentProject.IsBrightnessCalculated;
SimpleCalculationArea = ProjectManager.CurrentProject.SimpleCalculationArea;
ImageSavePath = ProjectManager.ImageSavePath;
CalcType = BrightnessCalcType.Advanced;
}
/// <summary>
/// Gets the actual or target cost entry for the given project type and the month.
/// </summary>
/// <param name="projectType">Type of project.</param>
/// <param name="costType">The actual or target cost indicator.</param>
/// <param name="month">Month for the calculation.</param>
/// <returns>The cost value.</returns>
public long GetCostEntry(ProjectType projectType, CostType costType, int month)
{
var key = ProjectCostEntry.ToString(projectType, costType, month);
if (this.costEntries.ContainsKey(key))
{
return this.costEntries[key].Cost;
}
return 0;
}
public ModisSourceProduct(string name, string baseUrl, SatelliteType sateType,
ProductType prodType, ProjectType projType, int days)
{
productName = name;
baseFtpUrl = baseUrl;
satellite = sateType;
productType = prodType;
projectType = projType;
observeInterval = days;
}
public Task AddProjectUploading(DomainActionData actionData, string projectId, string projectName, ProjectType projectType, ProjectSubtype projectSubtype)
{
string eventId = GuidWraper.Generate();
DateTime curDateTime = DateTimeWrapper.CurrentDateTime();
StatProjectUploadingV2Entity projectUploadingEntity = StatEntityFactory.CreateProjectUploadingEntity(eventId, curDateTime, actionData, projectId, projectName, projectType, projectSubtype);
ITableRepository<StatProjectUploadingV2Entity> projectUploadingRepository = RepositoryFactory.Create<StatProjectUploadingV2Entity>();
return projectUploadingRepository.AddAsync(projectUploadingEntity);
}
public ActionResult Create(ProjectType projecttype)
{
if (ModelState.IsValid)
{
db.ProjectTypes.Add(projecttype);
db.SaveChanges();
return RedirectToAction("Index");
}
return View(projecttype);
}
public VSProject CreateVSProjectFromFromFolder(string name, string folder, ProjectType type)
{
XmlDocument doc = new XmlDocument(new NameTable());
XmlNamespaceManager nsManager = new XmlNamespaceManager(doc.NameTable);
nsManager.AddNamespace("", "http://schemas.microsoft.com/developer/msbuild/2003");
nsManager.PushScope();
doc.Load(Path.Combine(context.TemplateFolder.FullName, "VS/CSProject_template.xml"));
return VSProject.Create(name, folder, type, doc);
}
public ActionResult Create(ProjectType ptype)
{
if (ModelState.IsValid)
{
ptype.Date_Creation = DateTime.Now;
context.ProjectTypes.Add(ptype);
context.SaveChanges();
return RedirectToAction("Index");
}
return View(ptype);
}
protected async Task<HttpResponseMessage> PostPackage(ProjectType projectType, ReleaseType releaseType,
string versionString)
{
string unescapedVersionString = versionString.Replace("-", ".");
Version version;
if (!Version.TryParse(unescapedVersionString, out version))
{
return Request.CreateErrorResponse(HttpStatusCode.UnsupportedMediaType,
"versionString is not valid: " + versionString);
}
if (!Request.Content.IsMimeMultipartContent())
{
return Request.CreateErrorResponse(HttpStatusCode.UnsupportedMediaType,
"Content must be mime multipart");
}
try
{
var name = string.Format("{0}_{1}_{2}.zip",
projectType,
releaseType,
unescapedVersionString);
Guid fileId;
using (var contentStream = await Request.Content.ReadAsStreamAsync())
{
fileId = Files.Create(name, contentStream);
}
var newFile = Context.Files.Single(file => file.FileId == fileId);
var package = new WurmAssistantPackage()
{
ProjectType = projectType,
ReleaseType = releaseType,
VersionString = unescapedVersionString,
File = newFile
};
Context.WurmAssistantPackages.Add(package);
RemoveOutdatedPackages(projectType, releaseType);
Context.SaveChanges();
return Request.CreateResponse(HttpStatusCode.OK);
}
catch (System.Exception e)
{
return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e);
}
}
private string GetOutputType(ProjectType type)
{
switch (type)
{
case ProjectType.Executable:
return "Exe";
case ProjectType.WindowsExecutable:
return "WinExe";
case ProjectType.Library:
return "Library";
default:
throw new ArgumentOutOfRangeException("type");
}
}
internal static string ToSerializableString(ProjectType type)
{
switch (type)
{
case ProjectType.StandardExe:
return "Exe";
case ProjectType.ActiveXExe:
return "OleExe";
case ProjectType.ActiveXDll:
return "OleDll";
case ProjectType.ActiveXControl:
return "Control";
default:
throw new ArgumentException("type");
}
}
public ProjectPreview(
int projectId,
Uri photoUri,
string name,
ProjectStatus projectStatus,
ProjectType[] projectTypes)
{
Require.Positive(projectId, nameof(projectId));
Require.NotEmpty(name, nameof(name));
Require.NotEmpty(projectTypes, nameof(projectTypes));
ProjectId = projectId;
PhotoUri = photoUri;
Name = name;
ProjectStatus = projectStatus;
ProjectTypes = projectTypes;
}
public static Type GetType(ProjectType projectType)
{
switch(projectType)
{
case ProjectType.CpuCore:
return typeof(CpuCoreProject);
case ProjectType.Extension:
return typeof(ExtensionProject);
case ProjectType.Plugin:
return typeof(PluginProject);
case ProjectType.Tests:
return typeof(TestsProject);
case ProjectType.UI:
return typeof(UiProject);
default:
return typeof(UnknownProject);
}
}
/// <summary>
/// Checks that the project info contains the expected values
/// </summary>
public static void AssertExpectedValues(
string expectedFullProjectPath,
string expectedProjectLanguage,
ProjectType expectedProjectType,
Guid expectedProjectGuid,
string expectedProjectName,
bool expectedIsExcluded,
ProjectInfo actualProjectInfo)
{
Assert.IsNotNull(actualProjectInfo, "Supplied ProjectInfo should not be null");
Assert.AreEqual(expectedFullProjectPath, actualProjectInfo.FullPath, "Unexpected FullPath");
Assert.AreEqual(expectedProjectLanguage, actualProjectInfo.ProjectLanguage, "Unexpected ProjectLanguage");
Assert.AreEqual(expectedProjectType, actualProjectInfo.ProjectType, "Unexpected ProjectType");
Assert.AreEqual(expectedProjectGuid, actualProjectInfo.ProjectGuid, "Unexpected ProjectGuid");
Assert.AreEqual(expectedProjectName, actualProjectInfo.ProjectName, "Unexpected ProjectName");
Assert.AreEqual(expectedIsExcluded, actualProjectInfo.IsExcluded, "Unexpected IsExcluded");
}
public IEnumerable<Project> GetProjectsOfType(ProjectType type)
{
switch(type)
{
case ProjectType.CpuCore:
return elements.OfType<CpuCoreProject>();
case ProjectType.Extension:
return elements.OfType<ExtensionProject>();
case ProjectType.Plugin:
return elements.OfType<PluginProject>();
case ProjectType.Tests:
return elements.OfType<TestsProject>();
case ProjectType.UI:
return elements.OfType<UiProject>();
default:
throw new ArgumentException("Unsupported project type");
}
}
public StatProjectUploadingV2Entity CreateProjectUploadingEntity(string eventId, DateTime dateTime, DomainActionData domain, string projectId, string projectName, ProjectType projectType,
ProjectSubtype projectSubtype)
{
string productName = _tableValueConverter.UserAgentToProductName(domain.UserAgent);
string productVersion = _tableValueConverter.UserAgentToVersion(domain.UserAgent);
return new StatProjectUploadingV2Entity
{
Tick = _tableValueConverter.DateTimeToTickWithGuid(dateTime),
EventId = eventId,
DateTime = dateTime,
ProductName = productName,
UserId = domain.UserId,
ProjectId = projectId,
ProjectName = projectName,
IdentityProvider = domain.IdentityProvider,
ProductVersion = productVersion,
ProjectType = (int)projectType,
TagType = (int)projectSubtype
};
}
protected string GetLatestVersion(ProjectType projectType, ReleaseType releaseType)
{
var packages = (from p in Context.WurmAssistantPackages
where p.ProjectType == projectType
&& p.ReleaseType == releaseType
orderby p.Created descending
select p).ToArray();
var latest = (from p in packages
orderby p.Version descending, p.Created descending
select p).FirstOrDefault();
if (latest == null)
{
return new Version(0,0,0,0).ToString();
}
else
{
return latest.VersionString;
}
}
public CreateProjectRequest(
string name,
ProjectType[] projectTypes,
string info,
ProjectStatus projectStatus,
AccessLevel accessLevel,
Image landingImage,
Image[] screenshots)
{
Require.NotEmpty(name, nameof(name));
Require.NotEmpty(info, nameof(info));
Require.NotEmpty(projectTypes, nameof(projectTypes));
Name = name;
ProjectTypes = projectTypes;
Info = info;
AccessLevel = accessLevel;
LandingImage = landingImage;
ProjectStatus = projectStatus;
Screenshots = screenshots;
}
protected HttpResponseMessage GetPackage(ProjectType projectType, ReleaseType releaseType, string versionString)
{
string unescapedVersionString = versionString.Replace("-", ".");
var package = (from p in Context.WurmAssistantPackages
where p.VersionString == unescapedVersionString
&& p.ProjectType == projectType
&& p.ReleaseType == releaseType
orderby p.Created descending
select p).FirstOrDefault();
if (package == null)
{
return new HttpResponseMessage(HttpStatusCode.NotFound);
}
var response = new HttpResponseMessage(HttpStatusCode.OK);
response.Content = new StreamContent(Files.Read(package.File.FileId));
response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = package.File.Name
};
return response;
}
public MainWindow(IGUIToolkit guiToolkit)
: base(Constants.SOFTWARE_NAME)
{
this.Build ();
this.guiToolKit = guiToolkit;
Title = Constants.SOFTWARE_NAME;
projectType = ProjectType.None;
ConnectSignals ();
ConnectMenuSignals ();
// Default screen
Screen screen = Display.Default.DefaultScreen;
// Which monitor is our window on
int monitor = screen.GetMonitorAtWindow (this.GdkWindow);
// Monitor size
Rectangle monitor_geometry = screen.GetMonitorGeometry (monitor);
// Resize to a convenient size
this.Resize (monitor_geometry.Width * 80 / 100, monitor_geometry.Height * 80 / 100);
if (Utils.RunningPlatform () == PlatformID.MacOSX) {
this.Move (monitor_geometry.Width * 10 / 100, monitor_geometry.Height * 10 / 100);
}
}
private string CreateRuleSet(string language, IEnumerable <SonarRule> activeRules, IEnumerable <SonarRule> inactiveRules, ProjectType projectType)
{
var ruleSetGenerator = new RoslynRuleSetGenerator(this.sonarProperties);
if (projectType == ProjectType.Test)
{
ruleSetGenerator.ActiveRuleAction = RuleAction.None;
}
var ruleSet = ruleSetGenerator.Generate(language, activeRules, inactiveRules);
Debug.Assert(ruleSet != null, "Expecting the RuleSet to be created.");
Debug.Assert(ruleSet.Rules != null, "Expecting the RuleSet.Rules to be initialized.");
var rulesetFilePath = Path.Combine(
this.teamBuildSettings.SonarConfigDirectory,
GetRoslynRulesetFileName(language, projectType));
this.logger.LogDebug(Resources.RAP_UnpackingRuleset, rulesetFilePath);
ruleSet.Save(rulesetFilePath);
return(rulesetFilePath);
}
public static DataTable getProjectType()
{
Query q = ProjectType.Query();
return(q.ExecuteDataSet().Tables[0]);
}
/// <summary>
/// Initializes a new instance of the <see cref="ProjectReference"/> class.
/// </summary>
/// <param name="id">The identifier.</param>
/// <param name="location">The location.</param>
/// <param name="type">The type.</param>
public ProjectReference(Guid id, UFile location, ProjectType type)
{
Id = id;
Location = location;
Type = type;
}
private Scintilla NewTextEditorActions(ProjectType projecttype, string title = "newTextEditorActions")
{
Scintilla scintilla = new Scintilla();
scintilla.Dock = DockStyle.Fill;
scintilla.KeyDown += new KeyEventHandler(newTextEditorActions_KeyDown);
scintilla.TextChanged += new EventHandler(newTextEditorActions_TextChanged);
// Reset the styles
scintilla.StyleResetDefault();
scintilla.Styles[Style.Default].Font = "Consolas";
scintilla.Styles[Style.Default].Size = 11;
scintilla.StyleClearAll();
scintilla.SetProperty("tab.timmy.whinge.level", "1");
scintilla.SetProperty("fold", "1");
// Use margin 2 for fold markers
scintilla.Margins[2].Type = MarginType.Symbol;
scintilla.Margins[2].Mask = Marker.MaskFolders;
scintilla.Margins[2].Sensitive = true;
scintilla.Margins[2].Width = 20;
// Reset folder markers
for (int i = Marker.FolderEnd; i <= Marker.FolderOpen; i++)
{
scintilla.Markers[i].SetForeColor(SystemColors.ControlLightLight);
scintilla.Markers[i].SetBackColor(SystemColors.ControlDark);
}
// Style the folder markers
scintilla.Markers[Marker.Folder].Symbol = MarkerSymbol.BoxPlus;
scintilla.Markers[Marker.Folder].SetBackColor(SystemColors.ControlText);
scintilla.Markers[Marker.FolderOpen].Symbol = MarkerSymbol.BoxMinus;
scintilla.Markers[Marker.FolderEnd].Symbol = MarkerSymbol.BoxPlusConnected;
scintilla.Markers[Marker.FolderEnd].SetBackColor(SystemColors.ControlText);
scintilla.Markers[Marker.FolderMidTail].Symbol = MarkerSymbol.TCorner;
scintilla.Markers[Marker.FolderOpenMid].Symbol = MarkerSymbol.BoxMinusConnected;
scintilla.Markers[Marker.FolderSub].Symbol = MarkerSymbol.VLine;
scintilla.Markers[Marker.FolderTail].Symbol = MarkerSymbol.LCorner;
// Enable automatic folding
scintilla.AutomaticFold = (AutomaticFold.Show | AutomaticFold.Click | AutomaticFold.Change);
switch (projecttype)
{
case ProjectType.Python:
scintilla.Lexer = Lexer.Python;
scintilla.Styles[Style.Python.Default].ForeColor = Color.FromArgb(0x80, 0x80, 0x80);
scintilla.Styles[Style.Python.CommentLine].ForeColor = Color.FromArgb(0x00, 0x7F, 0x00);
scintilla.Styles[Style.Python.CommentLine].Italic = true;
scintilla.Styles[Style.Python.Number].ForeColor = Color.FromArgb(0x00, 0x7F, 0x7F);
scintilla.Styles[Style.Python.String].ForeColor = Color.FromArgb(0x7F, 0x00, 0x7F);
scintilla.Styles[Style.Python.Character].ForeColor = Color.FromArgb(0x7F, 0x00, 0x7F);
scintilla.Styles[Style.Python.Word].ForeColor = Color.FromArgb(0x00, 0x00, 0x7F);
scintilla.Styles[Style.Python.Word].Bold = true;
scintilla.Styles[Style.Python.Triple].ForeColor = Color.FromArgb(0x7F, 0x00, 0x00);
scintilla.Styles[Style.Python.TripleDouble].ForeColor = Color.FromArgb(0x7F, 0x00, 0x00);
scintilla.Styles[Style.Python.ClassName].ForeColor = Color.FromArgb(0x00, 0x00, 0xFF);
scintilla.Styles[Style.Python.ClassName].Bold = true;
scintilla.Styles[Style.Python.DefName].ForeColor = Color.FromArgb(0x00, 0x7F, 0x7F);
scintilla.Styles[Style.Python.DefName].Bold = true;
scintilla.Styles[Style.Python.Operator].Bold = true;
scintilla.Styles[Style.Python.CommentBlock].ForeColor = Color.FromArgb(0x7F, 0x7F, 0x7F);
scintilla.Styles[Style.Python.CommentBlock].Italic = true;
scintilla.Styles[Style.Python.StringEol].ForeColor = Color.FromArgb(0x00, 0x00, 0x00);
scintilla.Styles[Style.Python.StringEol].BackColor = Color.FromArgb(0xE0, 0xC0, 0xE0);
scintilla.Styles[Style.Python.StringEol].FillLine = true;
scintilla.Styles[Style.Python.Word2].ForeColor = Color.FromArgb(0x40, 0x70, 0x90);
scintilla.Styles[Style.Python.Decorator].ForeColor = Color.FromArgb(0x80, 0x50, 0x00);
// Important for Python
scintilla.ViewWhitespace = WhitespaceMode.VisibleAlways;
break;
case ProjectType.CSScript:
case ProjectType.TagUI:
scintilla.Lexer = Lexer.Cpp;
scintilla.Styles[Style.Cpp.Default].ForeColor = Color.Silver;
scintilla.Styles[Style.Cpp.Comment].ForeColor = Color.FromArgb(0, 128, 0); // Green
scintilla.Styles[Style.Cpp.CommentLine].ForeColor = Color.FromArgb(0, 128, 0); // Green
scintilla.Styles[Style.Cpp.CommentLineDoc].ForeColor = Color.FromArgb(128, 128, 128); // Gray
scintilla.Styles[Style.Cpp.Number].ForeColor = Color.Olive;
scintilla.Styles[Style.Cpp.Word].ForeColor = Color.Blue;
scintilla.Styles[Style.Cpp.Word2].ForeColor = Color.Blue;
scintilla.Styles[Style.Cpp.String].ForeColor = Color.FromArgb(163, 21, 21); // Red
scintilla.Styles[Style.Cpp.Character].ForeColor = Color.FromArgb(163, 21, 21); // Red
scintilla.Styles[Style.Cpp.Verbatim].ForeColor = Color.FromArgb(163, 21, 21); // Red
scintilla.Styles[Style.Cpp.StringEol].BackColor = Color.Pink;
scintilla.Styles[Style.Cpp.Operator].ForeColor = Color.Purple;
scintilla.Styles[Style.Cpp.Preprocessor].ForeColor = Color.Maroon;
break;
//Could be useful later if we decide to allow users to open/edit the config file
//case Json:
// // Configure the JSON lexer styles
// scintilla.Lexer = Lexer.Json;
// scintilla.Styles[Style.Json.Default].ForeColor = Color.Silver;
// scintilla.Styles[Style.Json.BlockComment].ForeColor = Color.FromArgb(0, 128, 0); // Green
// scintilla.Styles[Style.Json.LineComment].ForeColor = Color.FromArgb(0, 128, 0); // Green
// scintilla.Styles[Style.Json.Number].ForeColor = Color.Olive;
// scintilla.Styles[Style.Json.PropertyName].ForeColor = Color.Blue;
// scintilla.Styles[Style.Json.String].ForeColor = Color.FromArgb(163, 21, 21); // Red
// scintilla.Styles[Style.Json.StringEol].BackColor = Color.Pink;
// scintilla.Styles[Style.Json.Operator].ForeColor = Color.Purple;
// break;
}
return(scintilla);
}
public ComboBoxProcessor(ProjectType projectType, ILogger logger)
: base(projectType, logger)
{
}
public MockProjectBuilder(string name, string filename, string projectId, ProjectProtection protection, ProjectType projectType, Func <IVBE> getVbe, MockVbeBuilder mockVbeBuilder)
{
_getVbe = getVbe;
_mockVbeBuilder = mockVbeBuilder;
_projectType = projectType;
_project = CreateProjectMock(name, filename, protection);
_project.SetupProperty(m => m.HelpFile);
_project.SetupGet(m => m.ProjectId).Returns(() => _project.Object.HelpFile);
_project.SetupGet(m => m.Type).Returns(_projectType);
_project.Setup(m => m.AssignProjectId())
.Callback(() => _project.Object.HelpFile = projectId);
_vbComponents = CreateComponentsMock();
_project.SetupGet(m => m.VBComponents).Returns(_vbComponents.Object);
_vbReferences = CreateReferencesMock();
_project.SetupGet(m => m.References).Returns(_vbReferences.Object);
}
public ButtonProcessor(ProjectType projectType, ILogger logger)
: base(projectType, logger)
{
}
internal async Task <IList <Transform.Project> > GetByType(ProjectType type)
{
return(await Projects.Where(p => p.ProjectType == type).Select(p => p.ToProject()).ToListAsync());
}
public ProjectM Add(Guid admin_user_id, Guid user_id, ProjectCreateM model)
{
try
{
if (!admin_user_id.Equals(Guid.Empty))
{
throw Forbidden();
}
if (model.Name.Contains("/"))
{
throw BadRequest("Project name can not contain slash(/)!");
}
ProjectType project_type = _projectType.GetOne(p => p.Id.Equals(model.ProjectTypeId));
if (project_type == null)
{
throw NotFound(model.ProjectTypeId, "project type id");
}
if (_project.Any(p => p.Name.Equals(model.Name) && p.Permissions.Any(p => p.UserId.Equals(user_id) && p.RoleId.Equals(RoleID.Admin))))
{
throw BadRequest("The project name is already existed!");
}
Project project = _project.Add(new Project
{
ProjectTypeId = model.ProjectTypeId,
IsDelete = false,
Name = model.Name,
StartDate = model.StartDate,
CreatedDate = DateTime.Now,
EndDate = model.EndDate
});
_permission.Add(new Permission
{
UserId = user_id,
ProjectId = project.Id,
RoleId = RoleID.Admin
});
_permission.Add(new Permission
{
UserId = user_id,
ProjectId = project.Id,
RoleId = RoleID.Project_Manager
});
SaveChanges();
return(new ProjectM
{
Id = project.Id,
CreatedDate = project.CreatedDate,
EndDate = project.EndDate,
Name = project.Name,
StartDate = project.StartDate,
ProjectType = new ProjectTypeM
{
Id = project_type.Id,
Name = project_type.Name
},
Owner = _user.Where(u => u.Id.Equals(user_id)).Select(u => new UserM
{
Id = u.Id,
Username = u.Username
}).FirstOrDefault()
});
}
catch (Exception e)
{
throw e is RequestException ? e : _errorHandler.WriteLog("An error occurred while add project!",
e, DateTime.Now, "Server", "Service_Project_Add");
}
}
static string func
(string projectDir, ProjectType projectType, List <string> targetVersion, Dictionary <string, string> packageReferences, List <string> projectReferences, List <string> metaReferences)
public static string GetRoslynRulesetFileName(string language, ProjectType projectType)
{
var testSuffix = projectType == ProjectType.Test ? "-test" : string.Empty;
return(string.Format(RoslynRulesetFileName, $"{language}{testSuffix}"));
}
/// <summary>
/// Chargement du fichier projet
/// </summary>
/// <returns>Retourn un ProjectError pour determiner le type d'erreur lors du chargement du projet</returns>
public ProjectError Load()
{
try{
if (File.Exists(this.FileName))
{
//Creation du reader
XmlDocument doc = new XmlDocument();
XmlTextReader reader = new XmlTextReader(this._FileName);
//Lecture du document
doc.Load(reader);
//Lecture des informations sur le projet
XmlNodeList nodes = doc.ChildNodes.Item(0).ChildNodes;
XmlNode node = nodes.Item(0);
try{
this._Author = node.Attributes["Author"].Value;
this._Description = node.Attributes["Description"].Value;
this._MD5Key = node.Attributes["MD5Key"].Value;
this._Name = node.Attributes["Name"].Value;
this._OutputPath = node.Attributes["OutputPath"].Value;
this._Email = node.Attributes["Email"].Value;
this._RLECompress = Convert.ToBoolean(node.Attributes["RLECompress"].Value);
this._HomePage = node.Attributes["HomePage"].Value;
this._RomFile = node.Attributes["RomFile"].Value;
this._WorkRomFile = node.Attributes["WorkRomFile"].Value;
//Type de projet
switch (node.Attributes["ProjectType"].Value)
{
case "SuperNintendo":
this._ProjectType = ProjectType.SuperNintendo;
break;
default:
this._ProjectType = ProjectType.SuperNintendo;
break;
}
}
catch {
return(ProjectError.ProjectSectionLoadError);
}
#region Chargement des Fichiers textes
//Lecture des includes : TextFile
int Total = 0;
XmlNodeList IncludeNodes = nodes.Item(0).ChildNodes.Item(0).ChildNodes;
node = IncludeNodes[0];
try{
Total = Convert.ToInt32(node.Attributes["Count"].Value); //Total de fichier texte
if (Total > 0)
{
XmlNodeList Textnodes = node.ChildNodes;
XmlNode Textnode;
TextFile txtFile;
//Chargement de tous les fichier texte
for (int i = 0; i < Total; i++)
{
Textnode = Textnodes[i];
txtFile = new TextFile();
txtFile.Name = Textnode.Attributes["Name"].Value;
txtFile.RelativePath = Textnode.Attributes["RelativePath"].Value;
txtFile.Extraction_TextBank_Start = Textnode.Attributes["Extraction_TextBank_Start"].Value;
txtFile.Extraction_TextBank_Stop = Textnode.Attributes["Extraction_TextBank_Stop"].Value;
txtFile.Extraction_PointeurBank_Start = Textnode.Attributes["Extraction_PointeurBank_Start"].Value;
txtFile.Extraction_PointeurBank_Stop = Textnode.Attributes["Extraction_PointeurBank_Stop"].Value;
txtFile.Extraction_HeaderAdjustement_Moins = Textnode.Attributes["Extraction_HeaderAdjustement_Moins"].Value;
txtFile.Extraction_HeaderAdjustement_Plus = Textnode.Attributes["Extraction_HeaderAdjustement_Plus"].Value;
txtFile.Insertion_TextBankStart = Textnode.Attributes["insertion_TextBankStart"].Value;
txtFile.Insertion_TextBankStop = Textnode.Attributes["insertion_TextBankStop"].Value;
txtFile.Insertion_PointeurBankStart = Textnode.Attributes["insertion_PointeurBankStart"].Value;
txtFile.Insertion_PointeurBankStop = Textnode.Attributes["insertion_PointeurBankStop"].Value;
txtFile.Insertion_HeaderAdjustementMoins = Textnode.Attributes["insertion_HeaderAdjustementMoins"].Value;
txtFile.Insertion_HeaderAdjustementPlus = Textnode.Attributes["insertion_HeaderAdjustementPlus"].Value;
txtFile.AucunPointeur = Convert.ToBoolean(Textnode.Attributes["AucunPointeur"].Value);
txtFile.Description = Textnode.Attributes["Description"].Value;
txtFile.InsertAtCompil = Convert.ToBoolean(Textnode.Attributes["InsertAtCompil"].Value);
txtFile.TablePath = Textnode.Attributes["TablePath"].Value;
txtFile.IsTextPointeurTable = Convert.ToBoolean(Textnode.Attributes["isTextPointeurTable"].Value);
txtFile.key = "txt" + Convert.ToString(this._TextFileArray.Count);
switch (Textnode.Attributes["Mode"].Value)
{
case "_16Bits":
txtFile.Mode = TextMode._16Bits;
break;
case "_24Bits":
txtFile.Mode = TextMode._24Bits;
break;
default:
txtFile.Mode = TextMode._16Bits;
break;
}
this._TextFileArray.Add(txtFile);
}
}
}
catch {
return(ProjectError.ProjectSectionLoadError);
}
#endregion
#region Chargement des fichiers HexaSnapShot
//Lecture des includes : HexaSnapShot
node = IncludeNodes[1];
Total = Convert.ToInt32(node.Attributes["Count"].Value); //Total de fichier texte
try{
if (Total > 0)
{
XmlNodeList HexaSnapNodes = node.ChildNodes;
XmlNode HexaSnapNode;
HexaSnapShot hexfile;
//Chargement de tous les fichier Hexasnap
for (int i = 0; i < Total; i++)
{
HexaSnapNode = HexaSnapNodes[i];
hexfile = new HexaSnapShot();
hexfile.Description = HexaSnapNode.Attributes["Description"].Value;
hexfile.StartPosition = HexaSnapNode.Attributes["StartPosition"].Value;
hexfile.Name = HexaSnapNode.Attributes["Name"].Value;
hexfile.RelativePath = HexaSnapNode.Attributes["RelativePath"].Value;
hexfile.InsertAtCompil = Convert.ToBoolean(HexaSnapNode.Attributes["InsertAtCompil"].Value);
hexfile.Key = "hex" + Convert.ToString(this._HexaSnapShotArray.Count);
this._HexaSnapShotArray.Add(hexfile);
}
}
}
catch {
return(ProjectError.HexaSnapShotSectionError);
}
#endregion
#region Chargement des fichiers Table TBL
//Lecture des includes : TableFile
node = IncludeNodes[2];
Total = Convert.ToInt32(node.Attributes["Count"].Value); //Total de fichier texte
try{
if (Total > 0)
{
XmlNodeList tblNodes = node.ChildNodes;
XmlNode tblNode;
TBLFile tbl;
//Chargement de tous les fichier TBL
for (int i = 0; i < Total; i++)
{
tblNode = tblNodes[i];
tbl = new TBLFile();
tbl.Description = tblNode.Attributes["Description"].Value;
tbl.Name = tblNode.Attributes["Name"].Value;
tbl.RelativePath = tblNode.Attributes["RelativePath"].Value;
tbl.Key = "tbl" + Convert.ToString(this._TBLFileArray.Count);
tbl.Default = Convert.ToBoolean(tblNode.Attributes["Default"].Value);
this._TBLFileArray.Add(tbl);
}
}
}
catch {
return(ProjectError.TableSectionError);
}
#endregion
#region Chargement des Tableaux a largeur fixe
//Lecture des includes : TableFixe
node = IncludeNodes[3];
Total = Convert.ToInt32(node.Attributes["Count"].Value); //Total de fichier texte
try{
if (Total > 0)
{
XmlNodeList FixeNodes = node.ChildNodes;
XmlNode FixeNode;
TableFixeFile fixefile;
//Chargement de tous les fichier TBL
for (int i = 0; i < Total; i++)
{
FixeNode = FixeNodes[i];
fixefile = new TableFixeFile();
fixefile.Description = FixeNode.Attributes["Description"].Value;
fixefile.TableauName = FixeNode.Attributes["TableauName"].Value;
fixefile.Largeur = Convert.ToInt16(FixeNode.Attributes["Largeur"].Value);
fixefile.Position = FixeNode.Attributes["Position"].Value;
fixefile.EmptyChar = FixeNode.Attributes["EmptyChar"].Value;
fixefile.TableName = FixeNode.Attributes["TableName"].Value;
fixefile.TotalCase = Convert.ToInt16(FixeNode.Attributes["TotalCase"].Value);
fixefile.Key = "tbl" + Convert.ToString(this._TBLFileArray.Count);
this._FixeTableArray.Add(fixefile);
}
}
}
catch {
return(ProjectError.FixeTableSectionError);
}
#endregion
#region Chargement des favoris (bookmarks)
//Bookmark nodes
XmlNodeList BookMarkNodes = nodes.Item(0).ChildNodes.Item(1).ChildNodes;
Total = BookMarkNodes.Count;
try{
if (Total > 0)
{
XmlNodeList MarkNodes = BookMarkNodes;
XmlNode MarkNode;
Favoris fav;
//Chargement de tous les Bookmark dans le projet
for (int i = 0; i < Total; i++)
{
MarkNode = MarkNodes[i];
fav = new Favoris();
fav.Position = MarkNode.Attributes["Position"].Value;
fav.Name = MarkNode.Attributes["Name"].Value;
fav.File = MarkNode.Attributes["File"].Value;
fav.Key = "mark" + Convert.ToString(this._FavorisFileArray.Count);
this._FavorisFileArray.Add(fav);
}
}
}
catch {
return(ProjectError.BookmarkSectionError);
}
#endregion
#region Chargement de la liste de tâches
//TaskList nodes
XmlNodeList TaskListNodes = nodes.Item(0).ChildNodes.Item(2).ChildNodes;
Total = TaskListNodes.Count;
try{
if (Total > 0)
{
XmlNodeList TaskNodes = TaskListNodes;
XmlNode TaskNode;
Task task;
//Chargement de tous les Bookmark dans le projet
for (int i = 0; i < Total; i++)
{
TaskNode = TaskNodes[i];
task = new Task();
task.File = TaskNode.Attributes["File"].Value;
task.Description = TaskNode.Attributes["Description"].Value;
task.Line = Convert.ToInt32(TaskNode.Attributes["Line"].Value);
task.TaskComplete = Convert.ToBoolean(TaskNode.Attributes["TaskComplete"].Value);
task.Key = "task" + Convert.ToString(this._TaskArray.Count);
switch (TaskNode.Attributes["Priority"].Value)
{
case "Faible":
task.Priority = TaskPriority.Faible;
break;
case "Normal":
task.Priority = TaskPriority.Normal;
break;
case "Haute":
task.Priority = TaskPriority.Haute;
break;
default:
task.Priority = TaskPriority.Normal;
break;
}
this._TaskArray.Add(task);
}
}
}
catch {
return(ProjectError.TaskListSectionError);
}
#endregion
//fin de la fonction
return(ProjectError.NoError); //Aucune erreur
}
else
{
return(ProjectError.FileNotFound); // Si aucun fichier charger
}
}
catch {
return(ProjectError.UnknowError);
}
}
private void CreateNewProject(out Project project, out ProjectType projectType,
out CaptureSettings captureSettings)
{
ProjectSelectionDialog psd;
NewProjectDialog npd;
List <Device> devices = null;
int response;
Log.Debug("Creating new project");
/* The out parameters must be set before leaving the method */
project = null;
projectType = ProjectType.None;
captureSettings = new CaptureSettings();
/* Show the project selection dialog */
psd = new ProjectSelectionDialog();
psd.TransientFor = mainWindow;
response = psd.Run();
psd.Destroy();
if (response != (int)ResponseType.Ok)
{
return;
}
projectType = psd.ProjectType;
if (projectType == ProjectType.CaptureProject)
{
devices = VideoDevice.ListVideoDevices();
if (devices.Count == 0)
{
MessagePopup.PopupMessage(mainWindow, MessageType.Error,
Catalog.GetString("No capture devices were found."));
return;
}
}
/* Show the new project dialog and wait to get a valid project
* or quit if the user cancel it.*/
npd = new NewProjectDialog();
npd.TransientFor = mainWindow;
npd.Use = projectType;
npd.TemplatesService = Core.TemplatesService;
if (projectType == ProjectType.CaptureProject)
{
npd.Devices = devices;
}
response = npd.Run();
while (true)
{
/* User cancelled: quit */
if (response != (int)ResponseType.Ok)
{
npd.Destroy();
return;
}
/* No file chosen: display the dialog again */
if (npd.Project == null)
{
MessagePopup.PopupMessage(mainWindow, MessageType.Info,
Catalog.GetString("Please, select a video file."));
}
/* If a project with the same file path exists show a warning */
else if (Core.DB.Exists(npd.Project))
{
MessagePopup.PopupMessage(mainWindow, MessageType.Error,
Catalog.GetString("This file is already used in another Project.") + "\n" +
Catalog.GetString("Select a different one to continue."));
}
else
{
/* We are now ready to create the new project */
project = npd.Project;
if (projectType == ProjectType.CaptureProject)
{
captureSettings = npd.CaptureSettings;
}
npd.Destroy();
break;
}
response = npd.Run();
}
if (projectType == ProjectType.FileProject)
{
/* We can safelly add the project since we already checked if
* it can can added */
Core.DB.AddProject(project);
}
}
public void PublicMethodArgumentsShouldBeCheckedForNull(ProjectType projectType) =>
Verifier.VerifyAnalyzer(@"TestCases\PublicMethodArgumentsShouldBeCheckedForNull.cs",
new SymbolicExecutionRunner(new PublicMethodArgumentsShouldBeCheckedForNull()),
ParseOptionsHelper.FromCSharp8,
#if NETFRAMEWORK
TestHelper.ProjectTypeReference(projectType).Concat(NuGetMetadataReference.NETStandardV2_1_0));
public EmulationState(ProjectType type)
{
Type = type;
}
public InternationalProject(string theme = "", ProjectType type = ProjectType.Applied, DateTime date = new DateTime(), string country_host = "", int participant_count = 0) :
base(theme, type, date)
{
this.country_host = country_host;
this.participant_count = participant_count;
}
/// <summary>
/// Checks the SolutionProject type
/// </summary>
/// <param name="project">The solutionproject</param>
/// <param name="projectType">The type to check</param>
/// <returns>true if the project type matches</returns>
public static bool IsType(this SolutionProject project, ProjectType projectType)
{
return(project.Type.EqualsIgnoreCase(Types[projectType]));
}
/// <summary>
/// Projects / Update Project
/// </summary>
/// <param name="projectId">Project ID</param>
/// <param name="name">Project Name</param>
/// <param name="type">Project Type</param>
public async Task <UpdateProjectResponse> UpdateProjectAsync(string projectId, string name, ProjectType type)
{
if (string.IsNullOrEmpty(projectId))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(projectId));
}
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(name));
}
if (type == null)
{
throw new ArgumentNullException("Value cannot be null.", nameof(type));
}
return(await ExecuteAsync <UpdateProjectResponse>(UpdateRequest <UpdateProjectRequest>(PROJECTS_PATH, projectId, new UpdateProjectRequest()
{
Id = projectId, Name = name, Type = type
})).ConfigureAwait(false));
}
private static ProjectTemplate PrepareTemplate(PackageTemplateGeneratorParameters parameters, UFile templateRelativePath, PlatformType platformType, string currentProfile, GraphicsPlatform?graphicsPlatform, ProjectType projectType)
{
ProjectTemplateGeneratorHelper.AddOption(parameters, "Platforms", parameters.GetTag(PlatformsKey).Select(x => x.Platform).ToList());
ProjectTemplateGeneratorHelper.AddOption(parameters, "CurrentPlatform", platformType);
ProjectTemplateGeneratorHelper.AddOption(parameters, "CurrentProfile", currentProfile);
ProjectTemplateGeneratorHelper.AddOption(parameters, "Orientation", parameters.GetTag(OrientationKey));
var package = parameters.Package;
return(ProjectTemplateGeneratorHelper.PrepareTemplate(parameters, package, templateRelativePath, platformType, graphicsPlatform, projectType));
}
private static string ResolveProjectName(string pageName, out ProjectType projectType)
{
if (pageName != pageName.AsciiOnly('.', ' ').CleanWhitespaces())
{
throw new ArgumentException($"Page name '{pageName}' does not look well-formed.");
}
var parts = pageName.Split(new[] { ' ' }, 2);
if (parts.Length != 2)
{
throw new ArgumentException($"Page name '{pageName}' does not look well-formed.");
}
var name = parts[0];
var type = parts[1];
switch (type)
{
case "library":
projectType = ProjectType.Library;
break;
case "web site":
projectType = ProjectType.Website;
break;
case "web service":
projectType = ProjectType.Webservice;
break;
case "service":
projectType = ProjectType.Service;
break;
case "console":
projectType = ProjectType.Console;
break;
case "application":
projectType = ProjectType.Windows;
break;
case "cloud role":
projectType = ProjectType.CloudRole;
break;
case "cloud service":
projectType = ProjectType.CloudService;
break;
case "fabric service":
projectType = ProjectType.FabricService;
break;
case "fabric application":
projectType = ProjectType.FabricApplication;
break;
default:
throw new InvalidOperationException($"Unknown project type '{type}'.");
}
return(name);
}
protected override Task OnTemplatesAvailableAsync()
{
ProjectType.LoadData();
return(Task.CompletedTask);
}
public MockProjectBuilder(string name, string filename, ProjectProtection protection, ProjectType projectType, Func <IVBE> getVbe, MockVbeBuilder mockVbeBuilder)
: this(
name,
filename,
Guid.NewGuid().ToString(),
protection,
projectType,
getVbe,
mockVbeBuilder
)
{
}
private static void AddProjectInfoToResult(ProjectInfoAnalysisResult result, ProjectInfoValidity validity, ProjectType type = ProjectType.Product, uint count = 1)
{
for (var i = 0; i < count; i++)
{
result.Projects.Add(new ProjectData(new ProjectInfo {
ProjectType = type
})
{
Status = validity
});
}
}
/// <summary>
/// Creates a new project info file in a new subdirectory with the given additional properties.
/// </summary>
private static string CreateProjectInfoInSubDir(string parentDir,
string projectName, Guid projectGuid, ProjectType projectType, bool isExcluded, string fullProjectPath, string encoding,
AnalysisProperties additionalProperties = null)
{
string newDir = Path.Combine(parentDir, Guid.NewGuid().ToString());
Directory.CreateDirectory(newDir); // ensure the directory exists
ProjectInfo project = new ProjectInfo()
{
FullPath = fullProjectPath,
ProjectName = projectName,
ProjectGuid = projectGuid,
ProjectType = projectType,
IsExcluded = isExcluded,
Encoding = encoding
};
if (additionalProperties != null)
{
project.AnalysisSettings = additionalProperties;
}
string filePath = Path.Combine(newDir, FileConstants.ProjectInfoFileName);
project.Save(filePath);
return(filePath);
}
public MenuFlyoutItemProcessor(ProjectType projectType, ILogger logger)
: base(projectType, logger)
{
}
public MediaElementProcessor(ProjectType projectType, ILogger logger)
: base(projectType, logger)
{
}
/// <summary>
/// Parses the specified node.
/// </summary>
/// <param name="node">The node.</param>
public override void Parse(XmlNode node)
{
m_Name = Helper.AttributeValue(node, "name", m_Name);
m_Path = Helper.AttributeValue(node, "path", m_Path);
m_FilterGroups = Helper.AttributeValue(node, "filterGroups", m_FilterGroups);
m_Version = Helper.AttributeValue(node, "version", m_Version);
m_AppIcon = Helper.AttributeValue(node, "icon", m_AppIcon);
m_ConfigFile = Helper.AttributeValue(node, "configFile", m_ConfigFile);
m_DesignerFolder = Helper.AttributeValue(node, "designerFolder", m_DesignerFolder);
m_AssemblyName = Helper.AttributeValue(node, "assemblyName", m_AssemblyName);
m_Language = Helper.AttributeValue(node, "language", m_Language);
m_Type = (ProjectType)Helper.EnumAttributeValue(node, "type", typeof(ProjectType), m_Type);
m_Runtime = (ClrRuntime)Helper.EnumAttributeValue(node, "runtime", typeof(ClrRuntime), m_Runtime);
m_Framework = (FrameworkVersion)Helper.EnumAttributeValue(node, "frameworkVersion", typeof(FrameworkVersion), m_Framework);
m_StartupObject = Helper.AttributeValue(node, "startupObject", m_StartupObject);
m_RootNamespace = Helper.AttributeValue(node, "rootNamespace", m_RootNamespace);
int hash = m_Name.GetHashCode();
Guid guidByHash = new Guid(hash, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
string guid = Helper.AttributeValue(node, "guid", guidByHash.ToString());
m_Guid = new Guid(guid);
m_GenerateAssemblyInfoFile = Helper.ParseBoolean(node, "generateAssemblyInfoFile", false);
m_DebugStartParameters = Helper.AttributeValue(node, "debugStartParameters", string.Empty);
if (string.IsNullOrEmpty(m_AssemblyName))
{
m_AssemblyName = m_Name;
}
if (string.IsNullOrEmpty(m_RootNamespace))
{
m_RootNamespace = m_Name;
}
m_FullPath = m_Path;
try
{
m_FullPath = Helper.ResolvePath(m_FullPath);
}
catch
{
throw new WarningException("Could not resolve Solution path: {0}", m_Path);
}
Kernel.Instance.CurrentWorkingDirectory.Push();
try
{
Helper.SetCurrentDir(m_FullPath);
if (node == null)
{
throw new ArgumentNullException("node");
}
foreach (XmlNode child in node.ChildNodes)
{
IDataNode dataNode = Kernel.Instance.ParseNode(child, this);
if (dataNode is ConfigurationNode)
{
HandleConfiguration((ConfigurationNode)dataNode);
}
else if (dataNode is ReferencePathNode)
{
m_ReferencePaths.Add((ReferencePathNode)dataNode);
}
else if (dataNode is ReferenceNode)
{
m_References.Add((ReferenceNode)dataNode);
}
else if (dataNode is AuthorNode)
{
m_Authors.Add((AuthorNode)dataNode);
}
else if (dataNode is FilesNode)
{
m_Files = (FilesNode)dataNode;
}
}
}
finally
{
Kernel.Instance.CurrentWorkingDirectory.Pop();
}
}
public LocalProject(string theme = "", ProjectType type = ProjectType.Applied, DateTime date = new DateTime(), double duration = 0.0, bool government_funds = false) :
base(theme, type, date)
{
this.duration = duration;
this.government_funds = government_funds;
}
public SynchronizeProjectProcessor(ProjectType projectType)
{
this.projectType = projectType;
}
public int GetProjectCount2(ProjectType type)
{
return(FindList(p => p.Type == type).Count());
}
