/// <summary>Validates the template.</summary>
/// <remarks>
/// The default implementation uses <see cref="Validator"/> to perform the validation.
/// </remarks>
protected override void Validate()
{
base.Validate();
var results = new List <ValidationResult>();
Validator.TryValidateObject(this, new ValidationContext(this), results, true);
foreach (var result in results)
{
Error(result.ErrorMessage);
}
;
if (!SkipDependencyChecks)
{
var dependencies = GetDependencies() ?? Enumerable.Empty <AssemblyDependency>();
if (dependencies.Any())
{
var checks = ActiveProject.CheckAssemblyReferences(dependencies);
int index = 0;
foreach (var dependency in dependencies)
{
if (!checks[index++])
{
Error("A reference to '{0}' version '{1}' or higher is required.", dependency.DisplayName, dependency.AssemblyVersion);
}
}
;
}
;
}
;
}
private string LoadDeleteFile(object automationObject, string entityName)
{
entityName = $"{entityName}.generated.cs";
var dte = (DTE)automationObject;
var selectItem = dte.SelectedItems.Item(1);
ProjectItems projectItems = null;
if (selectItem.Project != null)
{
projectItems = selectItem.Project.ProjectItems;
}
else if (selectItem.ProjectItem != null)
{
projectItems = selectItem.ProjectItem.ProjectItems;
}
if (projectItems == null)
{
return(string.Empty);
}
foreach (ProjectItem projectItem in projectItems)
{
if (entityName == projectItem.Name)
{
foreach (Window window in dte.Windows)
{
if (window.Caption == entityName)
{
window.Close();
}
}
var path = projectItem.FileNames[0];
File.Delete(path);
projectItem.Remove();
ActiveProject.Save();
return(path);
}
}
foreach (ProjectItem projectItem in projectItems)
{
foreach (ProjectItem childProjectItem in projectItem.ProjectItems)
{
if (entityName == childProjectItem.Name)
{
foreach (Window window in dte.Windows)
{
if (window.Caption == entityName)
{
window.Close();
}
}
var path = childProjectItem.FileNames[0];
File.Delete(path);
projectItem.Remove();
ActiveProject.Save();
return(path);
}
}
}
return(string.Empty);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
// Do whatever you want here
ActiveProject project = value as ActiveProject;
return(project == null ? project.Name : "Whatever");
}
private async void ProjectSaveAs_ExecuteRequested(XamlUICommand sender,
ExecuteRequestedEventArgs args)
{
ActiveProject.StorageFile = await PromptSaveLocation();
ActiveProject.Save();
}
private void SaveAs()
{
SaveFileDialog saveDialog = new SaveFileDialog();
if (saveDialog.ShowDialog() == DialogResult.OK)
{
ActiveProject.ProjectName = saveDialog.FileName;
ActiveProject.SaveState();
}
}
private void saveToolStripMenuItem_Click(object sender, EventArgs e)
{
if (ActiveProject != null)
{
ActiveProject.Save();
if (ActiveStage != null)
{
ActiveStage.Save();
}
}
}
private void tsmbtn_saveas_Click(object sender, EventArgs e)
{
using (SaveFileDialog sfd = new SaveFileDialog())
{
sfd.Filter = "Gif Maker Projects | *.gproj";
if (sfd.ShowDialog() == DialogResult.OK)
{
ActiveProject.SavePath = sfd.FileName;
ActiveProject.SaveMe(ActiveProject.SavePath);
}
}
}
private bool IsUsingEntityFrameworkWithAsyncSupport()
{
foreach (string assemblyPath in ActiveProject.GetAssemblyReferences())
{
AssemblyName assembly = AssemblyName.GetAssemblyName(assemblyPath);
if (assembly.Name.Equals(AssemblyVersions.AsyncEntityFrameworkAssemblyName))
{
return(assembly.Version >= AssemblyVersions.AsyncEntityFrameworkMinVersion);
}
}
// Since no reference to Entity Framework exists, the correct version will be added later by the system.
return(true);
}
public void RecoverGlobalTimer()
{
ActiveProject.Clear();
foreach (var p in Projects)
{
if (p.IsRunning)
{
p.SessionTime = DateTime.Now - p.SessionStartTime;
ActiveProject.Add(p);
}
}
StartGlobalTimer();
//MoveProjectToTop(ActiveProject[0]);
}
public async void ToggleTimer(object parameter)
{
var project = parameter as Project;
if (ActiveProject.Count > 0 && !project.IsRunning)
{
bool ans = await Application.Current.MainPage.DisplayAlert("Project Change", "You are currently working on other project\nDo you want to switch?", "Yes", "No");
if (ans)
{
Stop(ActiveProject[0]);
ActiveProject.Clear();
}
else
{
return;
}
}
if (!project.IsRunning)
{
ActiveProject.Add(project);
Start(project);
MoveProjectToTop(project);
}
else
{
try
{
Stop(project);
ActiveProject.Remove(project);
}
catch
{
await Application.Current.MainPage.DisplayAlert("Error", "Failed to stop, please try again", "Ok");
}
}
if (IsActive && ActiveProject.Count == 0)
{
StopGlobalTimer();
return;
}
if (!IsActive && ActiveProject.Count > 0)
{
StartGlobalTimer();
}
}
/* Toolbar Menu - Open Project Clicked */
private void MenuItemOpen_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog projectFinder = new OpenFileDialog();
projectFinder.Filter = "Workbench Project|*.mbwb|All files (*.*)|*.*";
projectFinder.FilterIndex = 1;
projectFinder.DefaultExt = "*.mbwb";
projectFinder.CheckFileExists = true;
projectFinder.Title = "Open Workbench Project";
projectFinder.InitialDirectory = Settings.UsersProjectHome;
if (projectFinder.ShowDialog() == true)
{
ActiveProject.Load(projectFinder.FileName);
}
}
public ActionResult DoAddResourceProject(ActiveResourceModel data)
{
List <ActiveProject> activeProject = new List <ActiveProject>();
ActiveProject projectToAdd = new ActiveProject();
bool flag = false;
int percentage = 0;
//ActiveResourceModel model = new ActiveResourceModel();
data model = new data();
using (ProjectToolsEntities db = new ProjectToolsEntities())
{
activeProject = db.ActiveProject.ToList();
foreach (ActiveProject a in activeProject)
{
if (data.ProjectResource == a.IDPerson)
{
percentage += data.ActiveProject.Percentage;
flag = true;
}
else if (data.ProjectResource != a.IDPerson && flag == false)
{
percentage += data.ActiveProject.Percentage;
flag = true;
}
}
if ((data.ActiveProject.Percentage + percentage) <= 100 && (data.ActiveProject.Percentage + percentage) > 0)
{
projectToAdd.IDPerson = data.ProjectResource;
projectToAdd.IDProject = data.IDProject;
projectToAdd.Percentage = data.ActiveProject.Percentage;
projectToAdd.StartActiveDate = data.ActiveProject.StartActiveDate;
projectToAdd.EndActiveDate = data.ActiveProject.EndActiveDate;
db.ActiveProject.Add(projectToAdd);
db.SaveChanges();
}
else
{
model.IDPerson = data.ProjectResource;
model.IDProject = data.IDProject;
ViewBag.MyErrorMessage = "The percentage is bigger than 100%, insert another percentage!";
return(RedirectToAction("AddResourceProject", model));
}
}
model.IDPerson = data.ProjectResource;
model.IDProject = data.IDProject;
return(RedirectToAction("Index"));
}
private void closeToolStripMenuItem_Click(object sender, EventArgs e)
{
if (ActiveProject == null)
{
return;
}
if (ActiveProject.Close())
{
projectForm.CloseProject();
tilestrip.ChangeTileset(null);
entityForm.Unload();
brushForm.Clear();
ActiveProject = null;
ActiveStage = null;
}
}
public void RunFinished()
{
ActiveProject.Save();
var projectItemsFile = ActiveProject.FullName.Replace(".shproj", ".projitems");
var arr = ClassGenerated.Split(@"\".ToCharArray());
var fileName = arr[arr.Length - 1];
var fileNameWithoutGenerator = fileName.Replace(".generated", "");
if (DeleteFile.Length > 0)
{
var lines = File.ReadAllLines(projectItemsFile);
var text = string.Empty;
var a = File.ReadAllText(projectItemsFile);
foreach (var line in lines)
{
var t = line;
if (line.EndsWith($"{fileName + (char)34} />", StringComparison.Ordinal))
{
var part1 = line.Substring(0,
line.IndexOf($"{fileName + (char)34} />", StringComparison.Ordinal));
text += part1 + fileNameWithoutGenerator + (char)34 + " />\r\n";
text += part1 + fileName + (char)34 +
$"><DependentUpon>{fileNameWithoutGenerator}</DependentUpon></Compile>\r\n";
}
else
{
text += line + "\r\n";
}
}
File.WriteAllText(projectItemsFile, text);
}
else
{
var find = $"{fileName + (char)34} />";
var replace =
$"{fileName + (char)34}>\r\n\t\t\t<DependentUpon>{fileNameWithoutGenerator}</DependentUpon>\r\n\t\t</Compile>";
var text = File.ReadAllText(projectItemsFile);
text = text.Replace(find, replace);
File.WriteAllText(projectItemsFile, text);
}
File.WriteAllText(ActiveProject.FullName, File.ReadAllText(ActiveProject.FullName) + " ");
var temp = File.ReadAllText(projectItemsFile).TrimEnd();
File.WriteAllText(projectItemsFile, temp + " ");
}
protected string GetFileFullPath(string name, string codeFileExtension)
{
string fileName = name + "." + codeFileExtension;
var files = Directory.GetFiles(ActiveProject.GetFullPath(), fileName, SearchOption.AllDirectories);
if (files.Length == 1)
{
return(files.FirstOrDefault());
}
else if (files.Length == 0)
{
throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, Resources.FileNotFound, fileName));
}
else
{
throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, Resources.FilesFoundMore, fileName));
}
}
/// <summary>
/// This method is called after the project is created.
/// </summary>
public void RunFinished()
{
if (IsNewItem)
{
// Create function name from project items
FunctionName = ReplacementsDictionary["$safeitemname$"];
if (IsItemAddedToKeyins)
{
AddCommand();
}
ActiveProject.Save();
}
//else
// RequestRestart();
// Set cursor as default arrow
Cursor.Current = Cursors.Default;
}
protected override void Execute()
{
if (ActiveProject == null)
{
return;
}
var project = ActiveProject.As <EnvDTE.Project>();
var vsBuildPropertyStorage = ActiveProject.AsVsHierarchy() as IVsBuildPropertyStorage;
if (vsBuildPropertyStorage != null)
{
var storage = new BuildPropertyStorage(vsBuildPropertyStorage);
var viewModel = new PackageMetadataViewModel(storage);
if (!packageInstallerServices.IsBuildPackagingNuGetInstalled(project))
{
// Provide default values for required fields/properties
viewModel.PackageId = project.Name;
viewModel.PackageVersion = "1.0.0";
viewModel.Description = project.Name;
viewModel.Authors = "MyCompany";
}
var view = new PackageMetadataView()
{
DataContext = viewModel
};
if (dialogService.ShowDialog(view) == true)
{
storage.CommitChanges();
if (!packageInstallerServices.IsBuildPackagingNuGetInstalled(project))
{
packageInstaller.InstallBuildPackagingNuget(project);
}
buildService.Pack(ActiveProject);
}
}
}
private async void ProjectOpen_ExecuteRequested(XamlUICommand sender,
ExecuteRequestedEventArgs args)
{
// Prompt user to save unsaved changes (if applicable)
if (await ProceedAfterPromptToSaveChanges() == false)
{
return;
}
ActiveProject = null;
var picker = new FileOpenPicker
{
ViewMode = PickerViewMode.Thumbnail,
SuggestedStartLocation = PickerLocationId.Desktop,
CommitButtonText = "Open",
FileTypeFilter = { ".mbp" }
};
var file = await picker.PickSingleFileAsync();
if (file == null)
{
return;
}
ActiveProject = await Project.Load(file);
var title = AppTitleText;
var mediaFiles = ActiveProject.GetAllMediaFiles <MediaTreeFile>() as MediaTreeFile[] ??
ActiveProject.GetAllMediaFiles <MediaTreeFile>().ToArray();
// Get each file from its storage location
for (var i = 0; i < mediaFiles.Length; i++)
{
await mediaFiles[i].GetFileFromPathAsync();
AppTitleText = $"{title} - Loading ({mediaFiles.Length - i} files remaining)";
}
AppTitleText = title;
}
public ActionResult DoAddProjectResource(ActiveResourceModel data)
{
List <ActiveProject> activeProject = new List <ActiveProject>();
ActiveProject projectToAdd = new ActiveProject();
bool flag = false;
int percentage = 0;
using (ProjectToolsEntities db = new ProjectToolsEntities())
{
activeProject = db.ActiveProject.ToList();
foreach (ActiveProject a in activeProject)
{
if (data.ProjectResource == a.IDPerson)
{
percentage += a.Percentage;
flag = true;
}
else if (data.ProjectResource != a.IDPerson && flag == false)
{
percentage += a.Percentage;
}
}
if ((data.ActiveProject.Percentage + percentage) <= 100)
{
projectToAdd.IDPerson = data.ProjectResource;
projectToAdd.IDProject = data.IDProject;
projectToAdd.Percentage = data.ActiveProject.Percentage;
projectToAdd.StartActiveDate = data.ActiveProject.StartActiveDate;
projectToAdd.EndActiveDate = data.ActiveProject.EndActiveDate;
db.ActiveProject.Add(projectToAdd);
db.SaveChanges();
}
else
{
TempData["msg"] = "<script>alert('The percentage is bigger than 100%!');</script>";
}
}
return(RedirectToAction("AssegnaProject"));
}
public ActionResult AddProjectResource(int IDPerson, int IDProject)
{
ActiveProjectModel projectResource = new ActiveProjectModel();
ActiveProject activeProject = null;
Project projects = null;
using (ProjectToolsEntities db = new ProjectToolsEntities())
{
activeProject = db.ActiveProject.Where(l => l.IDPerson == l.IDPerson).FirstOrDefault();
if (projectResource.Percentage >= 100)
{
TempData["msg"] = "<script>alert('Impossibile to add project at this resource');</script>";
}
else
{
projects = db.Project.Where(l => l.IDPerson == IDPerson).FirstOrDefault();
projectResource.ProjectResource = projects.IDProject;
projectResource.IDPerson = IDPerson;
}
}
return(PartialView(projectResource));
}
internal void UpdateImage()
{
ActiveProject.DataValues.TotalImages = (ActiveProject.irps as List <irp>).Count;
ActiveProject.ValidateIrps();
string[] data = new string[5];
for (int i = 0; i < data.Length; i++)
{
data[i] = "";
}
try
{
UpdateSlave.RunSlave(out data[0],
out data[1],
out data[2],
out data[3],
out data[4]);
}
catch { }
l_imageIndex.Text = data[0];
label4.Text = data[1];
label6.Text = data[2];
label3.Text = data[3];
label2.Text = data[4];
}
public MainWindowViewModel()
{
_openProjects = new ObservableCollection <ProjectViewModel>();
SelectProjectCommand = new RelayCommand <ProjectViewModel>((project) =>
{
SelectActiveProject(project);
});
NewProjectCommand = new RelayCommand(() =>
{
var proj = new ProjectViewModel();
proj.ProjectName = ProjectViewModel.UnNamedProjectName; // bug waiting to happen. names should be more unique because of how saving saving works at
SelectActiveProject(proj);
OpenProjects.Add(proj);
});
CloseActiveProjectCommand = new RelayCommand(() =>
{
if (ActiveProject != null)
{
// TODO: Ask if to save first
ActiveProject.SaveState();
OpenProjects.Remove(ActiveProject);
SelectActiveProject(OpenProjects.LastOrDefault());
}
});
OpenProjectCommand = new RelayCommand(() =>
{
OpenFileDialog openFileDialog = new OpenFileDialog();
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
var proj = ProjectViewModel.FromFile(openFileDialog.FileName);
if (proj != null)
{
SelectActiveProject(proj);
OpenProjects.Add(proj);
}
}
});
SaveProjectCommand = new RelayCommand(() => {
if (ActiveProject.ProjectName == ProjectViewModel.UnNamedProjectName)
{
SaveAs();
}
else
{
ActiveProject.SaveState();
}
});
SaveAsProjectCommand = new RelayCommand(() =>
{
SaveAs();
});
CloseAllCommand = new RelayCommand(() => {
foreach (var item in OpenProjects)
{
item.SaveState();
}
ActiveProject = null;
OpenProjects.Clear();
});
}
private void SaveProject()
{
ActiveProject.Save();
GC.Collect();
GC.WaitForPendingFinalizers();
}
private void tsmbtn_save_Click(object sender, EventArgs e)
{
ActiveProject.SaveMe(ActiveProject.SavePath);
}
/// <summary>
/// Add locate command, placement command, toolbar, winforms, and wpf function name to
/// KeyinCommands.cs or KeyinCommands.vb and commands.xml.
/// </summary>
private void AddCommand()
{
foreach (ProjectItem projectItem in ActiveProject.ProjectItems)
{
try
{
Window objWindow;
Boolean bHasOpenWindow;
bHasOpenWindow = projectItem.IsOpen;
if (
projectItem.Name.ToLower() == "commands.xml" ||
projectItem.Name.ToLower() == "keyincommands.cs" ||
projectItem.Name.ToLower() == "keyincommands.vb" ||
projectItem.Name.ToLower() == "keyincommands.cpp")
{
if (!bHasOpenWindow)
{
objWindow = projectItem.Open(EnvDTE.Constants.vsViewKindCode);
}
}
Document document;
if (projectItem.Name != "Properties" && projectItem.Name != "My Project")
{
document = projectItem.Document;
if (document != null)
{
if (document.Name.ToLower() == "commands.xml")
{
ModifyCommandTable(projectItem);
}
else if
(document.Name.ToLower() == "keyincommands.cs" ||
document.Name.ToLower() == "keyincommands.vb" ||
document.Name.ToLower() == "keyincommands.cpp")
{
string keyinCommandFunctionCS = "";
string keyinCommandFunctionVB = "";
string keyinCommandFunctionCPP = "";
switch (GetItemTypeFromTemplate)
{
case "MicroStation Selection Tool":
keyinCommandFunctionCS = AddFunctionCode2(FunctionName, "tool", "InstallNewInstance(unparsed)", ProjectLanguage.CS);
keyinCommandFunctionVB = AddFunctionCode2(FunctionName, "tool", "InstallNewInstance(unparsed)", ProjectLanguage.VB);
break;
case "MicroStation Selection Tool Settings":
keyinCommandFunctionCS = AddFunctionCode2(FunctionName, "tool", "InstallNewInstance(unparsed)", ProjectLanguage.CS);
keyinCommandFunctionVB = AddFunctionCode2(FunctionName, "tool", "InstallNewInstance(unparsed)", ProjectLanguage.VB);
break;
case "MicroStation Selection Tool Settings WPF":
keyinCommandFunctionCS = AddFunctionCode2(FunctionName, "tool", "InstallNewInstance(unparsed)", ProjectLanguage.CS);
keyinCommandFunctionVB = AddFunctionCode2(FunctionName, "tool", "InstallNewInstance(unparsed)", ProjectLanguage.VB);
break;
case "MicroStation IPrimitive Tool Settings":
keyinCommandFunctionCS = AddFunctionCode(FunctionName, "tool", "Run(unparsed)", ProjectLanguage.CS);
keyinCommandFunctionVB = AddFunctionCode(FunctionName, "tool", "Run(unparsed)", ProjectLanguage.VB);
break;
case "MicroStation IPrimitive Tool Settings WPF":
keyinCommandFunctionCS = AddFunctionCode(FunctionName, "tool", "Run(unparsed)", ProjectLanguage.CS);
keyinCommandFunctionVB = AddFunctionCode(FunctionName, "tool", "Run(unparsed)", ProjectLanguage.VB);
break;
case "MicroStation Placement Tool":
keyinCommandFunctionCS = AddFunctionCode2(FunctionName, "tool", "InstallNewInstance(unparsed)", ProjectLanguage.CS);
keyinCommandFunctionVB = AddFunctionCode2(FunctionName, "tool", "InstallNewInstance(unparsed)", ProjectLanguage.VB);
break;
case "MicroStation Placement Tool Settings":
keyinCommandFunctionCS = AddFunctionCode2(FunctionName, "tool", "InstallNewInstance(unparsed)", ProjectLanguage.CS);
keyinCommandFunctionVB = AddFunctionCode2(FunctionName, "tool", "InstallNewInstance(unparsed)", ProjectLanguage.VB);
break;
case "MicroStation Placement Tool Settings WPF":
keyinCommandFunctionCS = AddFunctionCode2(FunctionName, "tool", "InstallNewInstance(unparsed)", ProjectLanguage.CS);
keyinCommandFunctionVB = AddFunctionCode2(FunctionName, "tool", "InstallNewInstance(unparsed)", ProjectLanguage.VB);
break;
case "MicroStation Tool Settings WPF":
keyinCommandFunctionCS = AddFunctionCode(FunctionName, "tool", "ShowWindow(Program.Addin, unparsed)", ProjectLanguage.CS);
keyinCommandFunctionVB = AddFunctionCode(FunctionName, "tool", "ShowWindow(Program.Addin, unparsed)", ProjectLanguage.VB);
break;
case "MicroStation Tool Settings":
keyinCommandFunctionCS = AddFunctionCode(FunctionName, "tool", "ShowForm(Program.Addin, unparsed)", ProjectLanguage.CS);
keyinCommandFunctionVB = AddFunctionCode(FunctionName, "tool", "ShowForm(Program.Addin, unparsed)", ProjectLanguage.VB);
break;
case "MicroStation Toolbar WPF":
keyinCommandFunctionCS = AddFunctionCode(FunctionName, "toolbar", "ShowToolbar(unparsed)", ProjectLanguage.CS);
keyinCommandFunctionVB = AddFunctionCode(FunctionName, "toolbar", "ShowToolbar(unparsed)", ProjectLanguage.VB);
break;
case "MicroStation Windows Form":
keyinCommandFunctionCS = AddFunctionCode(FunctionName, "form", "ShowForm(unparsed)", ProjectLanguage.CS);
keyinCommandFunctionCPP = FunctionName + "::ShowForm(Program::MSAddin);";
keyinCommandFunctionVB = AddFunctionCode(FunctionName, "form", "ShowForm(unparsed)", ProjectLanguage.VB);
break;
case "MicroStation UserControl (WPF)":
keyinCommandFunctionCS = AddFunctionCode(FunctionName, "usercontrol", "ShowWindow(unparsed)", ProjectLanguage.CS);
keyinCommandFunctionVB = AddFunctionCode(FunctionName, "usercontrol", "ShowWindow(unparsed)", ProjectLanguage.VB);
break;
case "MicroStation Class":
keyinCommandFunctionCS = FunctionName + " " + FunctionName.ToLower() + " = new " + FunctionName + "();";
keyinCommandFunctionVB = "Dim " + FunctionName.ToLower() + " As " + FunctionName + " = new " + FunctionName + "()";
break;
default:
break;
}
ModifyKeyinsCommands(projectItem,
keyinCommandFunctionCS,
keyinCommandFunctionVB,
keyinCommandFunctionCPP);
}
}
ActiveProject.Save();
}
}
catch (Exception)
{
//do nothing
}
}
}
public string GetErrorIfInvalidIdentifier(string text)
{
return(ValidationUtil.GetErrorIfInvalidIdentifier(text, ActiveProject.GetCodeLanguage()));
}
/// <summary>
/// Loads a topic by its topic Id
/// </summary>
/// <param name="topicId"></param>
public void LoadTopicById(string topicId)
{
ActiveTopic = ActiveProject.LoadTopic(topicId);
}
void ReflectClasses(AssemblyDefinition asy, ProjectType projectFrameworkType, String projectFrameworkVersion, ClassEntities classEntities, ActiveProject activeProject)
{
if (asy == null)
{
throw new ArgumentNullException(nameof(asy));
}
if (classEntities == null)
{
throw new ArgumentNullException(nameof(classEntities));
}
if (!Enum.IsDefined(typeof(ProjectType), projectFrameworkType))
{
throw new InvalidEnumArgumentException(nameof(projectFrameworkType), (int)projectFrameworkType, typeof(ProjectType));
}
if (string.IsNullOrWhiteSpace(projectFrameworkVersion))
{
throw new ArgumentException("Value cannot be null or white space.", nameof(projectFrameworkVersion));
}
if (!Enum.IsDefined(typeof(ActiveProject), activeProject))
{
throw new InvalidEnumArgumentException(nameof(activeProject), (int)activeProject, typeof(ActiveProject));
}
foreach (TypeDefinition type in asy.MainModule.GetTypes())
{
if ((type.IsPublic || (activeProject == ActiveProject.Yes && type.IsNotPublic && !type.IsNestedPrivate)) && type.IsClass && !type.IsAbstract && !type.Name.StartsWith("<") && !type.Name.Contains("AnonymousType") && type.Name != "AssemblyInfo" && !type.Name.StartsWith("__"))
{
var previouslyLoaded = false;
foreach (var classEntity in classEntities)
{
if (type.Name == classEntity.ClassName && type.Namespace == classEntity.NamespaceName && asy.Name.Name == classEntity.AssemblyName)
{
previouslyLoaded = true;
break;
}
}
if (!previouslyLoaded)
{
if (type.BaseType == null || type.BaseType.Name != "MulticastDelegate")
{
classEntities.Add(new ClassEntity(asy, type, projectFrameworkType, projectFrameworkVersion));
}
}
}
}
}
/* User clicks "create project" button */
private void CreateProjectButton_Click(object sender, RoutedEventArgs e)
{
if (MapName.Text.Length == 0 || !MapName.Text.ToLower().Equals(MapName.Text) || !MapName.Text.Replace(" ", "").Equals(MapName.Text))
{
MessageBox.Show("Your map name must contain no spaces, no capitals and not match an existing map");
return;
}
if (Prefix.Text.Length == 0 || !Prefix.Text.ToLower().Equals(Prefix.Text) || !Prefix.Text.Replace(" ", "").Equals(Prefix.Text))
{
MessageBox.Show("Your prefix must contain no spaces, no capitals and not match an existing map");
return;
}
if (Maps.SelectedItem == null || Maps.SelectedItem.ToString().Length == 0)
{
MessageBox.Show("Please select a valid base map");
return;
}
if (Directory.Exists(Path.Combine(Settings.UsersProjectHome, MapName.Text)))
{
MessageBox.Show("A map with this name already exists in your projects folder");
return;
}
if (ImportedData.importedMaps.Where(x => x.name == MapName.Text).Any())
{
MessageBox.Show("A map with this name already exists in game");
return;
}
/* Append Underscore */
if (!Prefix.Text.EndsWith("_"))
{
Prefix.Text = Prefix.Text + "_";
}
MainWindow mainWindow = WindowFinder.FindOpenWindowByType <MainWindow>();
/* Setup Current Project */
ActiveProject.Project = new Project();
ActiveProject.Project.name = MapName.Text;
ActiveProject.Project.map = ImportedData.importedMaps.Where(x => x.name == Maps.SelectedItem.ToString()).FirstOrDefault();
ActiveProject.Project.directory = Path.Combine(Settings.UsersProjectHome, ActiveProject.Project.name);
ActiveProject.Project.file = Path.Combine(Settings.UsersProjectHome, ActiveProject.Project.name, ActiveProject.Project.name + ".mbwb");
ActiveProject.Project.prefix = Prefix.Text;
/* Create the Project Directory */
Directory.CreateDirectory(ActiveProject.Project.directory);
/* Create Maps and ext_data */
Directory.CreateDirectory(Path.Combine(ActiveProject.Project.directory, "maps"));
Directory.CreateDirectory(Path.Combine(ActiveProject.Project.directory, "ext_data"));
/* Extract the map from it's PK3 */
using (ZipArchive zipFile = ZipFile.OpenRead(Path.Combine(Settings.MBIIDirectory, ActiveProject.Project.map.parentPK3)))
{
ZipArchiveEntry mapFile = zipFile.GetEntry(ActiveProject.Project.map.entryPath);
mapFile.ExtractToFile(Path.Combine(ActiveProject.Project.directory, "maps", ActiveProject.Project.map.fileName));
}
/* Rename the BSP to that of current project name */
File.Move(Path.Combine(ActiveProject.Project.directory, "maps", ActiveProject.Project.map.fileName), Path.Combine(ActiveProject.Project.directory, "maps", ActiveProject.Project.name + ".bsp"));
/* Prefill teams, characters and siege info if this base map has available */
Siege defaultSiege = ImportedData.importedSieges.Where(x => x.map == ActiveProject.Project.map.name).FirstOrDefault();
if (defaultSiege != null && defaultSiege.team1 != null && defaultSiege.team2 != null)
{
ActiveProject.Project.siege = defaultSiege;
foreach (Team team in ImportedData.importedTeams.Where(x => x.name == ActiveProject.Project.siege.team1.useTeam || x.name == ActiveProject.Project.siege.team2.useTeam).ToList())
{
Team newTeam = team;
team.name = ActiveProject.Project.prefix + team.name;
foreach (Character character in team.Characters())
{
Character newCharacter = character;
character.classinfo.name = ActiveProject.Project.prefix + character.classinfo.name;
ActiveProject.Project.characters.Add(newCharacter);
}
/* TODO: We still need to loop the team and change character names to include new prefix here */
ActiveProject.Project.teams.Add(newTeam);
}
}
/* Save Project */
ActiveProject.Save();
/* Update the GUI */
ActiveProject.TreeAddSources();
this.Close();
}
/* Toolbar Menu - Save Project Clicked */
private void MenuItemSave_Click(object sender, RoutedEventArgs e)
{
ActiveProject.Save();
}
