public static string ProposeFileName(this Reference source, FileNameTrimType fileNameTrimType = FileNameTrimType.None)
{
if (source == null)
{
return(null);
}
var renameSettings = source.Project.Engine.Settings.Engine.Settings.Rename;
// TODO DL: für 5.2 abändern http://tfs2012:8080/tfs/CITAVICollection/Citavi/_workitems/edit/17175
//var values = renameSettings.NameDefineIds .Select(id => GetValue(source, id)).ToList();
var values = new List <ReferencePropertyId> {
ReferencePropertyId.ShortTitle
}.Select(id => source.GetReferencePropertybyId(id)).ToList();
values.RemoveAll(v => string.IsNullOrWhiteSpace(v));
var result = string.Join(renameSettings.Separator.ToStringSeparator(), values);
if (string.IsNullOrEmpty(result))
{
return(null);
}
result = Path2.GetValidFileName(result.Clean());
if (fileNameTrimType != FileNameTrimType.None)
{
result = result.Trim(fileNameTrimType, renameSettings.MaxNameLength);
}
return(result);
}
// Eventhandlers
void BtnFolderBrowserDialog_Click(object sender, EventArgs e)
{
using (var folderBrowseDialog = new FolderBrowserDialog {
Description = Properties.Resources.FolderBrowseDialogDescription
})
{
var root = Path2.GetFullPathFromPathWithVariables(txtPath.Text);
if (System.IO.Directory.Exists(root))
{
folderBrowseDialog.SelectedPath = root;
}
if (folderBrowseDialog.ShowDialog(this) != DialogResult.OK)
{
return;
}
var entry = GetPathWithVariablesFromFullPath(folderBrowseDialog.SelectedPath);
if (!string.IsNullOrEmpty(entry) && !folderBrowseDialog.SelectedPath.Equals(entry, StringComparison.OrdinalIgnoreCase) && MessageBox.Show(this, Properties.Resources.PathAsVariableMessage.FormatString(folderBrowseDialog.SelectedPath, entry), Owner.ProductName, MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
txtPath.Text = entry;
lblEnvironmentFullPath.Text = Path2.GetFullPathFromPathWithVariables(entry);
}
else
{
txtPath.Text = folderBrowseDialog.SelectedPath;
lblEnvironmentFullPath.Text = folderBrowseDialog.SelectedPath;
}
}
}
void RunTravers(MacroContainer container, bool supressMessage = false)
{
if (IsValidDirectory(out string message))
{
var menu = GetMacroMenu(container.Form);
if (menu != null)
{
var button = menu.InsertCommandbarButton(1, Key_Button_OpenInExplorer, MacroManagerResources.OpenInExplorerCommand);
container.Tools.Add(button.Tool, "OpenInExplorerCommand");
}
var macrosDirectory = Path2.GetFullPathFromPathWithVariables(Settings[Key_MacrosDirectory]);
int folderCounter = 1;
int fileCounter = 1;
if (Directory.Exists(macrosDirectory))
{
DirectoryConverter.Travers(menu, 3, ref folderCounter, ref fileCounter, macrosDirectory, container, true);
}
}
else
{
if (!supressMessage)
{
MessageBox.Show(container.Form, message, container.Form.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
static async Task <List <FetchResult> > FetchReferencesByFileAsync(MainForm mainForm, string directory, IProgress <PercentageAndTextProgressInfo> progress, CancellationToken cancellationToken)
{
var results = new List <FetchResult>();
var pathes = Path2.GetFilesSafe(new DirectoryInfo(directory), "*.pdf", SearchOption.AllDirectories).Select(fileInfo => fileInfo.FullName).ToList();
var fileImportSupport = new FileImportSupport();
for (var i = 0; i < pathes.Count; i++)
{
cancellationToken.ThrowIfCancellationRequested();
var path = pathes[i];
var referencesFromFile = await fileImportSupport.ImportFilesAsync(mainForm.Project, mainForm.Project.Engine.TransformerManager, new List <string>() { path }, AttachmentAction.Copy);
if ((bool)referencesFromFile?.Any())
{
results.Add(new FetchResult {
Path = path, References = referencesFromFile
});
}
progress.Report(new PercentageAndTextProgressInfo {
Percentage = Convert.ToInt32(100 / pathes.Count * i)
});
}
return(results);
}
// Methods
void InitializeDirectory(string directory)
{
if (!string.IsNullOrEmpty(directory))
{
txtPath.Text = directory;
lblEnvironmentFullPath.Text = Path2.GetFullPathFromPathWithVariables(directory);
}
}
void ToolStripItem_ItemClick(object sender, EventArgs e)
{
if (sender is ToolStripItem item)
{
txtPath.Text = item.Text;
lblEnvironmentFullPath.Text = Path2.GetFullPathFromPathWithVariables(item.Text);
}
}
public void Perform(MVVMNode node)
{
if (!EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo())
{
return;
}
if (!EditorUtility.DisplayDialog("Warning!", "Before scaffolding the core, make sure you saved and compiled!",
"Yes, I saved and compiled!",
"Cancel"))
{
return;
}
var paths = InvertApplication.Container.Resolve <DatabaseService>().CurrentConfiguration.CodeOutputPath + "/";
var scenesPath = System.IO.Path.Combine(paths, "Scenes");
var sceneName = node.Graph.Namespace + "KernelScene.unity";
var sceneNameWithPath = System.IO.Path.Combine(scenesPath, sceneName);
var prefabName = node.Graph.Namespace + "Kernel.prefab";
var prefabNameWithPath = Path2.Combine(paths, prefabName);
var relativeScenesPath = System.IO.Path.Combine(paths, "Scenes");
var relativeScenePath = System.IO.Path.Combine(relativeScenesPath + "/", sceneName);
uFrameKernel uFrameMVVMKernel = null;
if (File.Exists(sceneNameWithPath))
{
var gameObject = (GameObject)AssetDatabase.LoadAssetAtPath(prefabNameWithPath, typeof(GameObject));
uFrameMVVMKernel = gameObject.GetComponent <uFrameKernel>();
SyncKernel(node, uFrameMVVMKernel.gameObject);
}
else
{
var eScene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
if (!Directory.Exists(scenesPath))
{
Directory.CreateDirectory(scenesPath);
}
uFrameMVVMKernel = FindComponentInScene <uFrameKernel>() ?? new GameObject("Kernel").AddComponent <uFrameKernel>();
var services = SyncKernel(node, uFrameMVVMKernel.gameObject);
services.gameObject.AddComponent <ViewService>();
services.gameObject.AddComponent <SceneManagementService>();
PrefabUtility.CreatePrefab(prefabNameWithPath, uFrameMVVMKernel.gameObject, ReplacePrefabOptions.ConnectToPrefab);
EditorSceneManager.SaveScene(eScene, relativeScenePath);
}
if (!UnityEditor.EditorBuildSettings.scenes.Any(s => s.path.EndsWith(node.Graph.SystemPath + "KernelScene.unity")))
{
var list = EditorBuildSettings.scenes.ToList();
list.Add(new EditorBuildSettingsScene(relativeScenePath, true));
EditorBuildSettings.scenes = list.ToArray();
}
AssetDatabase.Refresh();
}
public void OnGUI()
{
if (!_capturing)
{
if (GUILayout.Button("Generate Documentation"))
{
var repository = InvertGraphEditor.DesignerWindow.DiagramViewModel.CurrentRepository;
_screenshots = repository.AllOf <GraphNode>().ToList();
_capturing = true;
NextScreenshot();
}
return;
}
if (drawer == null)
{
return;
}
foreach (var item in drawer.Children)
{
//if (!(item is DiagramNodeDrawer)) continue;
//if (item is ScreenshotNodeDrawer) continue;
item.Draw(InvertGraphEditor.PlatformDrawer, 1f);
}
if (Event.current.type == EventType.Repaint)
{
Texture2D texture2D = new Texture2D(Mathf.RoundToInt(this.position.width), Mathf.RoundToInt(this.position.height), (TextureFormat)3, false);
texture2D.ReadPixels(new Rect(0f, 0f, this.position.width, this.position.height), 0, 0);
texture2D.Apply();
byte[] bytes = texture2D.EncodeToPNG();
Object.DestroyImmediate((Object)texture2D, true);
var directory = Path.Combine("Documentation", "Screenshots");
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
File.WriteAllBytes(Path2.Combine("Documentation", "Screenshots", _screenshots[_currentScreenshotIndex - 1].Name + ".png"), bytes);
Debug.Log("Saved image " + _screenshots[_currentScreenshotIndex - 1].Name + ".png");
NextScreenshot();
}
//this.Close();
}
internal static void CheckInvalidPathChars(string path, bool checkAdditional = false)
{
if (path != null)
{
if (!Path2.HasIllegalCharacters(path, checkAdditional))
{
return;
}
else
{
throw new ArgumentException("The path has invalid characters.", "path");
}
}
else
{
throw new ArgumentNullException("path");
}
}
bool ExistDirectory(string directory)
{
if (string.IsNullOrEmpty(directory))
{
MessageBox.Show(this, Properties.Resources.FolderBrowseDialogDescription, Owner.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return(false);
}
var path = Path2.GetFullPathFromPathWithVariables(directory);
if (System.IO.Directory.Exists(path))
{
return(true);
}
MessageBox.Show(this, Properties.Resources.DirectoryNotResolveMessage.FormatString(path), Owner.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
bool IsValidDirectory(out string message)
{
message = null;
if (!Settings.ContainsKey(Key_MacrosDirectory))
{
message = MacroManagerResources.ConfigurateAddonMessage;
return(false);
}
if (!Directory.Exists(Path2.GetFullPathFromPathWithVariables(Settings[Key_MacrosDirectory])))
{
message = MacroManagerResources.DirectoryNotFoundMessage;
return(false);
}
return(true);
}
public static void Run(MainForm mainForm)
{
var counter = 0;
string sourcePath;
using (var folderDialog = new FolderBrowserDialog {
Description = ImportPdfsAndCategorySystemResource.FolderBrowserDialogDescription
})
{
if (folderDialog.ShowDialog() != DialogResult.OK)
{
return;
}
sourcePath = folderDialog.SelectedPath;
}
var action = AttachmentAction.Copy;
var directoryInfo = new DirectoryInfo(sourcePath);
var fileInfos = Path2.GetFilesSafe(directoryInfo, "*.pdf", SearchOption.AllDirectories).ToList();
var newReferences = new List <Reference>();
foreach (var filePath in fileInfos.Select(info => info.FullName).ToList())
{
var referencesFromFile = new FileImportSupport().ImportFiles(mainForm.Project, mainForm.Project.Engine.TransformerManager, new List <string>()
{
filePath
}, action);
if (referencesFromFile != null && referencesFromFile.Any())
{
var referencesFromFileAdded = mainForm.Project.References.AddRange(referencesFromFile);
var fileName = Path.GetFileName(filePath);
AddCategories(referencesFromFileAdded, filePath.Substring(sourcePath.Length, filePath.Length - sourcePath.Length - fileName.Length));
counter++;
}
}
MessageBox.Show(mainForm, ImportPdfsAndCategorySystemResource.MacroResultMessage.FormatString(counter), mainForm.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
public static string GetFileName(string path)
{
char chr;
if (path != null)
{
Path2.CheckInvalidPathChars(path, false);
int length = path.Length;
int num = length;
do
{
int num1 = num - 1;
num = num1;
if (num1 < 0)
{
return(path);
}
chr = path[num];
}while (chr != Path2.DirectorySeparatorChar && chr != Path2.AltDirectorySeparatorChar && chr != Path2.VolumeSeparatorChar);
return(path.Substring(num + 1, length - num - 1));
}
return(path);
}
/// <summary>
/// Compiles .cs script into dll/pdb, loads as assembly, and executes Main function.
/// Temporary dll/pdb gets deleted. If .cs throws exception - it will be converted to
/// error information, including .cs filename and source code line information.
/// </summary>
/// <param name="_path">Path to script which to execute</param>
/// <param name="bAllowThrow">true if allow to throw exceptions</param>
/// <param name="errors">Errors if any</param>
/// <param name="args">Main argument parameters</param>
/// <param name="bCompileOnly">true if only to compile</param>
/// <returns>true if execution was successful.</returns>
static public bool RunScript(String _path, bool bCompileOnly, bool bAllowThrow, out String errors, params String[] args)
{
errors = "";
// ----------------------------------------------------------------
// Load script
// ----------------------------------------------------------------
String path = Path.GetFullPath(_path);
if (!File.Exists(path))
{
errors = "Error: Could not load file '" + Exception2.getPath(path) + "': File does not exists.";
if (bAllowThrow)
{
throw new Exception2(errors, 1);
}
return(false);
}
// Create syncProj cache folder next to syncProj.exe executable.
String cacheDir = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "syncProjCache");
if (!Directory.Exists(cacheDir))
{
DirectoryInfo di = Directory.CreateDirectory(cacheDir);
di.Attributes = FileAttributes.Directory | FileAttributes.Hidden;
}
String dllBaseName = Path.GetFileNameWithoutExtension(_path);
String tempDll;
String dllInfoFile = "";
DateTime dllInfoRealDate = DateTime.MinValue;
for (int i = 1; ; i++)
{
tempDll = Path.Combine(cacheDir, dllBaseName);
if (i != 1)
{
tempDll += i;
}
dllInfoFile = tempDll + "_script.txt"; // We keep here C# script full path just not to get collisions.
if (!File.Exists(dllInfoFile))
{
File.WriteAllText(dllInfoFile, path);
break;
}
String pathFromFile = "";
//
// Another instance of syncProj might be accessing same file at the same time, we try to retry automatically after some delay.
//
for (int iTry = 0; iTry < 20; iTry++)
{
try
{
pathFromFile = File.ReadAllText(dllInfoFile);
break;
}
catch (Exception)
{
Thread.Sleep(10 + iTry * 5); // 5*20+10, overall (5*20+10)*20 / 2 = 1.1 sec
}
}
if (pathFromFile == path)
{
dllInfoRealDate = File.GetLastWriteTime(dllInfoFile);
break;
}
}
String pdb = tempDll + ".pdb";
tempDll += ".dll";
List <String> filesToCompile = new List <string>();
filesToCompile.Add(path);
//---------------------------------------------------------------------------------------------------
// Get referenced .cs script file list, and from referenced files further other referenced files.
//---------------------------------------------------------------------------------------------------
CsScriptInfo csInfo = getCsFileInfo(filesToCompile[0], true);
filesToCompile.AddRange(csInfo.csFiles);
bool bCompileDll = false;
//---------------------------------------------------------------------------------------------------
// Compile .dll only if script.cs and it's dependent .cs are newer than compiled .dll.
//---------------------------------------------------------------------------------------------------
if (!File.Exists(tempDll))
{
bCompileDll = true;
}
DateTime dllInfoTargetDate = DateTime.MinValue;
//---------------------------------------------------------------------------------------------------
// Calculate target date anyway, so we can set it to file.
// I have made such logic that scripts will be compiled if date / time of main script or any sub-script is changed.
//---------------------------------------------------------------------------------------------------
List <long> times = filesToCompile.Select(x => File.GetLastWriteTime(x).Ticks).ToList();
//
// If we are referencing any local .dll file, add it's time into calculation scheme.
//
foreach (String refDll in csInfo.refFiles)
{
if (File.Exists(refDll))
{
times.Add(File.GetLastAccessTime(refDll).Ticks);
}
}
// If syncProj.exe also changed, requires recompiling all .dll's.
// GetEntryAssembly() returns null during unit testing.
String exeFile = System.Reflection.Assembly.GetExecutingAssembly().Location;
times.Add(File.GetLastWriteTime(exeFile).Ticks);
times.Sort();
//---------------------------------------------------------------------------------------------------
// Basically we have multiple files, each with it's own modification date, we need to detect if any of files
// has changed - either updated forth (svn update) or back (svn revert with set file dates to last commit time)
// We try to calculate date / time from multiple date times
//---------------------------------------------------------------------------------------------------
long time = times[0]; // smallest date/time
for (int i = 1; i < times.Count; i += 2)
{
if (i + 1 == times.Count)
{
time = (time + times[i]) / 2; // medium between current date/time and highest
}
else
{
time += (times[i + 1] - times[i]) / 2; // just take different between dates / times and get medium from there.
}
}
dllInfoTargetDate = new DateTime(time);
if (times.Count != 1)
{
dllInfoTargetDate.AddSeconds(-times.Count); // Just some checksum on how many files we actually have.
}
if (!bCompileDll)
{
if (dllInfoRealDate != dllInfoTargetDate)
{
bCompileDll = true;
}
}
if (csInfo.DebugEnabled())
{
if (!bCompileDll)
{
Console.WriteLine(Exception2.getPath(path) + " dll is up-to-date.");
}
else
{
Console.WriteLine(Exception2.getPath(path) + " dll will be compiled.");
}
//+ ": Date found: " + dllInfoRealDate.ToString("o") + " Date expected: " + dllInfoTargetDate.ToString("o")
}
if (bCompileDll)
{
// ----------------------------------------------------------------
// Compile it into ram
// ----------------------------------------------------------------
if (provider == null)
{
provider = new CSharpCodeProvider();
}
#pragma warning disable 618
if (compiler == null)
{
compiler = provider.CreateCompiler();
}
#pragma warning restore 618
CompilerParameters compilerparams = new CompilerParameters();
compilerparams.GenerateExecutable = false;
#if NODEBUGTRACE
// Currently it's not possible to generate in ram pdb debugging information.
// Compiler option /debug:full should in theory allow that, but it does not work.
compilerparams.GenerateInMemory = true;
#else
compilerparams.GenerateInMemory = false;
compilerparams.IncludeDebugInformation = true; // Needed to get line / column numbers
compilerparams.OutputAssembly = tempDll;
compilerparams.CompilerOptions = "/d:DEBUG /d:TRACE"; // /debug+ /debug:full /optimize-
#endif
// Add assemblies from my domain - all which are not dynamic.
if (refAssemblies == null)
{
var assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(a => !a.IsDynamic).Select(a => a.Location).ToList();
for (int i = 0; i < assemblies.Count; i++)
{
if (assemblies[i].EndsWith(".exe") && !assemblies[i].EndsWith("\\syncproj.exe"))
{
assemblies.RemoveAt(i);
i--;
}
}
refAssemblies = assemblies.ToArray();
}
compilerparams.ReferencedAssemblies.AddRange(refAssemblies);
foreach (var f in csInfo.refFiles)
{
compilerparams.ReferencedAssemblies.Add(f);
}
// ----------------------------------------------------------------
// If compile errors - report and exit.
// ----------------------------------------------------------------
CompilerResults results = compiler.CompileAssemblyFromFileBatch(compilerparams, filesToCompile.ToArray());
if (results.Errors.HasErrors)
{
// Mimic visual studio error handling.
StringBuilder sb = new StringBuilder();
foreach (CompilerError error in results.Errors)
{
// Missing reference file will not give any file or line information, we just use compilation
// script filename, and first line position. (Not exactly right, but something at least).
if (error.FileName == "")
{
sb.Append(Exception2.getPath(filesToCompile[0]));
}
else
{
sb.Append(Exception2.getPath(error.FileName));
}
if (error.Line == 0)
{
// error CS0006: Metadata file 'MystiqueDll.dll' could not be found
sb.Append("(1,1)");
}
else
{
sb.Append("(" + error.Line + "," + error.Column + ")");
}
sb.AppendFormat(": error {0}: {1}\r\n", error.ErrorNumber, error.ErrorText);
}
errors = sb.ToString();
if (bAllowThrow)
{
throw new Exception2(errors);
}
return(false);
}
} //if
try
{
File.SetLastWriteTime(dllInfoFile, dllInfoTargetDate);
}
catch (Exception)
{
// Visual studio can launch multiple instances of syncProj, and then each will try to compile it's own copy.
// Add here just some guard, let's check if this needs to be improved later on.
}
if (bCompileOnly)
{
return(true);
}
//------------------------------------------------------------------------------------------------------
//
// Let's check that script contains correct css_ref (Might be copied from another project).
// We allow here also multiple copies of syncProj, as long as path to syncProj.exe is valid in .cs header
// (Can be edited by C# script)
//
//------------------------------------------------------------------------------------------------------
Regex reCssRef = new Regex("^ *//css_ref *(.*syncproj\\.exe);?([\r\n]+|$)", RegexOptions.Multiline | RegexOptions.IgnoreCase);
bool bUpdateScriptPath = false;
String targetCsPath = "";
using (StreamReader reader = new StreamReader(path))
{
for (int i = 0; i < 10; i++)
{
String line = reader.ReadLine() ?? "";
var re = reCssRef.Match(line);
if (re.Success)
{
// Current path, referred from C# script
String currentCsPath = re.Groups[1].Value;
String dir = Path.GetDirectoryName(path);
String exePath = SolutionOrProject.getSyncProjExeLocation(dir, currentCsPath);
targetCsPath = Path2.makeRelative(exePath, dir);
String referredExe = currentCsPath;
if (!Path.IsPathRooted(referredExe)) // Uses relative path, let's make it absolute.
{
referredExe = Path.Combine(dir, currentCsPath);
}
if (currentCsPath != targetCsPath && !File.Exists(referredExe))
{
bUpdateScriptPath = true; // Path is not the same as ours, and .exe referred by C# script does not exists.
}
} //if
} //for
} //using
if (bUpdateScriptPath)
{
String file = File.ReadAllText(path);
String newFile = reCssRef.Replace(file, new MatchEvaluator(m => { return("//css_ref " + targetCsPath + "\r\n"); }));
File.WriteAllText(path, newFile);
}
// ----------------------------------------------------------------
// Preload compiled .dll and it's debug information into ram.
// ----------------------------------------------------------------
MethodInfo entry = null;
String funcName = "";
Assembly asm = Assembly.LoadFrom(tempDll);
//Assembly asm = results.CompiledAssembly;
// ----------------------------------------------------------------
// Locate entry point
// ----------------------------------------------------------------
BindingFlags flags = BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.IgnoreCase;
Type builderClass = null;
foreach (Type type in asm.GetTypes())
{
funcName = "Main";
entry = type.GetMethod(funcName, flags);
if (entry == null)
{
funcName = "ScriptMain";
entry = type.GetMethod(funcName, flags);
}
if (entry != null)
{
builderClass = type;
break;
}
}
if (entry == null)
{
errors = String.Format("{0}(1,1): error: Code does not have 'Main' function\r\n", Exception2.getPath(path));
if (bAllowThrow)
{
throw new Exception2(errors);
}
return(false);
}
if (entry.GetParameters().Length != 1)
{
errors = String.Format("{0}(1,1): error: Function '{1}' is not expected to have {2} parameter(s)\r\n", Exception2.getPath(path), funcName, entry.GetParameters().Length);
if (bAllowThrow)
{
throw new Exception2(errors);
}
return(false);
}
String oldScriptRelativeDir = SolutionProjectBuilder.m_scriptRelativeDir;
String scriptSubPath = Path2.makeRelative(Path.GetDirectoryName(_path), SolutionProjectBuilder.m_workPath);
SolutionProjectBuilder.m_scriptRelativeDir = scriptSubPath;
String oldScriptPath = SolutionProjectBuilder.m_currentlyExecutingScriptPath;
SolutionProjectBuilder.m_currentlyExecutingScriptPath = _path;
String oldDir = Environment.CurrentDirectory;
//
// We set current directory to where script is, just so script can use Directory.GetFiles without specifying directory.
//
Directory.SetCurrentDirectory(Path.GetDirectoryName(_path));
// ----------------------------------------------------------------
// Run script
// ----------------------------------------------------------------
try
{
entry.Invoke(null, new object[] { args });
Directory.SetCurrentDirectory(oldDir);
SolutionProjectBuilder.m_scriptRelativeDir = oldScriptRelativeDir;
SolutionProjectBuilder.m_currentlyExecutingScriptPath = oldScriptPath;
}
catch (Exception ex)
{
Directory.SetCurrentDirectory(oldDir);
SolutionProjectBuilder.m_scriptRelativeDir = oldScriptRelativeDir;
SolutionProjectBuilder.m_currentlyExecutingScriptPath = oldScriptPath;
Exception2 ex2 = ex.InnerException as Exception2;
if (ex2 != null && bAllowThrow)
{
throw ex2;
}
try
{
StackFrame[] stack = new StackTrace(ex.InnerException, true).GetFrames();
StackFrame lastCall = stack[0];
errors = String.Format("{0}({1},{2}): error: {3}\r\n", path,
lastCall.GetFileLineNumber(), lastCall.GetFileColumnNumber(), ex.InnerException.Message);
} catch (Exception ex3)
{
errors = String.Format("{0}(1,1): error: Internal error - exception '{3}'\r\n", path, ex3.Message);
}
if (bAllowThrow)
{
throw new Exception2(errors);
}
return(false);
}
return(true);
} //RunScript
protected override void OnBeforePerformingCommand(BeforePerformingCommandEventArgs e)
{
e.Handled = true;
var container = _containers.FirstOrDefault(c => c.Form.Equals(e.Form));
switch (e.Key)
{
case (Key_Button_ShowMacroEditor):
{
CurrentEditor(e.Form, false, out bool hidden, out bool isNew).Activate();
}
break;
case (Key_Button_Refresh):
{
UpdateTools(container);
}
break;
case (Key_Button_Config):
{
using (var directoryDialog = new DirectoryDialog(Settings.TryGetStringValue(Key_MacrosDirectory))
{
Owner = e.Form
})
{
if (directoryDialog.ShowDialog() == DialogResult.OK)
{
Settings[Key_MacrosDirectory] = directoryDialog.Directory;
Program.Settings.InitialDirectories.SetInitialDirectoryContext(Citavi.Settings.InitialDirectoryContext.Macros, Path2.GetFullPathFromPathWithVariables(directoryDialog.Directory));
UpdateTools(container);
}
}
}
break;
case (Key_Button_OpenInExplorer):
{
if (IsValidDirectory(out string message))
{
var path = Path2.GetFullPathFromPathWithVariables(Settings[Key_MacrosDirectory]);
Process.Start("explorer.exe", path);
}
else
{
MessageBox.Show(e.Form, message, e.Form.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
break;
default:
if (e.Key.StartsWith(Key_Button_Directory, StringComparison.OrdinalIgnoreCase))
{
if (container.Macros.ContainsKey(e.Key))
{
var macro = container.Macros[e.Key];
if (File.Exists(macro.Path))
{
var hide = macro.Action == MacroAction.Run;
_editor = CurrentEditor(e.Form, hide, out bool hidden, out bool isNew);
if (!isNew && _editor.IsDirty())
{
if (MessageBox.Show(e.Form, MacroManagerResources.UserWarningSaveMessage, e.Form.ProductName, MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
{
_editor.Save();
}
}
_editor.MacroCode = File.ReadAllText(macro.Path);
_editor.SetFilePath(macro.Path);
_editor.Activate();
if (macro.Action == MacroAction.Run)
{
_editor.Run();
}
if (hidden)
{
_editor.Close();
}
}
else
{
MessageBox.Show(e.Form, MacroManagerResources.PathNotFoundMessage.FormatString(macro.Path), e.Form.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
UpdateTools(container, true);
}
}
else
{
e.Handled = false;
}
}
else
{
e.Handled = false;
}
break;
}
base.OnBeforePerformingCommand(e);
}
static void DoTest1()
{
Console.WriteLine("This script ran from: " + Path2.makeRelative(getCsDir(), m_workPath));
Console.WriteLine("Script name: " + getCsFileName());
} //Main
private void DownloadAll()
{
try
{
UserCredential credential;
using (var stream =
new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);
credPath = Path.Combine(credPath, ".credentials/drive-dotnet-quickstart.json");
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets, Scopes, "user", CancellationToken.None, new FileDataStore(credPath, true)).Result;
}
// Create Drive API service.
var service = new DriveService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
// Define parameters of request.
FilesResource.ListRequest listRequest = service.Files.List();
listRequest.PageSize = 10;
listRequest.Fields = "nextPageToken, files(id, name)";
var request = service.Files.List();
request.Spaces = "appDataFolder";
request.Fields = "nextPageToken, files(id, name)";
request.PageSize = 10;
var result = request.Execute();
var driveFiles = result.Files.ToList();
Directory.CreateDirectory("Budgets");
var localFiles = Directory.EnumerateFiles(_path, "*.sqlite").ToList();
foreach (var file in localFiles)
{
var fileName = Path.GetFileName(file);
if (driveFiles.Any(x => x.Name.Equals(fileName) && File.GetLastWriteTime(file) < x.ModifiedTime))
{
//DOWNLOAD NEW VERSION TO PC
Dispatcher.Invoke((Action)(() =>
{
_budgetList.Add(new Budget(fileName, Path.GetFullPath(file), Path.GetFileNameWithoutExtension(file)));
var budget = _budgetList.First(x => x.Name.Equals(fileName));
budget.LoadAble = false;
budget.State = "Updating";
ListViewBudgets.ItemsSource = _budgetList;
ListViewBudgets.Items.Refresh();
}));
var fileId = driveFiles.First(x => x.Name.Equals(Path.GetFileName(file))).Id;
var downloadRequest = service.Files.Get(fileId);
var stream = new MemoryStream();
downloadRequest.Download(stream);
var downloadPath = Path.Combine(_path, Path2.GetFileName(file));
stream.Position = 0;
var fileStream = File.Create(downloadPath);
stream.CopyTo(fileStream);
fileStream.Close();
Dispatcher.Invoke(() =>
{
var budget = _budgetList.First(x => x.Name.Equals(fileName));
budget.LoadAble = true;
budget.State = "Ready";
ListViewBudgets.ItemsSource = _budgetList;
ListViewBudgets.Items.Refresh();
});
}
}
foreach (var file in driveFiles)
{
if (!localFiles.Any(x => Path.GetFileName(x).Equals(file.Name)))
{
//DOWNLOAD NEW BUDGET TO PC
this.Dispatcher.Invoke((Action)(() =>
{
string noExtension = file.Name;
string[] a = noExtension.Split('.');
noExtension = a[0];
_budgetList.Add(new Budget(file.Name, "", noExtension));
var budget = _budgetList.First(x => x.Name.Equals(file.Name));
budget.LoadAble = false;
budget.State = "Downloading";
ListViewBudgets.ItemsSource = _budgetList;
ListViewBudgets.Items.Refresh();
}));
var fileId = file.Id;
var downloadRequest = service.Files.Get(fileId);
var stream = new System.IO.MemoryStream();
downloadRequest.Download(stream);
var downloadPath = Path.Combine(_path, file.Name);
stream.Position = 0;
var fileStream = File.Create(downloadPath);
stream.CopyTo(fileStream);
fileStream.Close();
this.Dispatcher.Invoke((Action)(() =>
{
var budget = _budgetList.First(x => x.Name.Equals(file.Name));
budget.Path = Path.GetFullPath(downloadPath);
budget.NameWithoutExtension = Path.GetFileNameWithoutExtension(downloadPath);
budget.LoadAble = false;
budget.State = "Ready";
ListViewBudgets.ItemsSource = _budgetList;
ListViewBudgets.Items.Refresh();
}));
}
}
}
catch (Exception exception) when(exception is Google.GoogleApiException || exception is HttpRequestException)
{
bool retry = false;
Dispatcher.Invoke((Action)(() =>
{
YesNo yesNo = new YesNo("Quickbudget failed to connect to Google Drive. Do you want to try again?")
{
Owner = GetWindow(this)
};
yesNo.ShowDialog();
if (yesNo.IsSuccesful)
{
retry = true;
}
}));
if (retry)
{
DownloadAll();
}
else
{
//TODO load local
}
}
}
public static void Main()
{
if (Program.ProjectShells.Count == 0)
{
return; //no project open
}
if (IsBackupAvailable() == false)
{
return; //user wants to backup his/her project first
}
int counter = 0;
try
{
string sourcePath;
FolderBrowserDialog folderDialog = new FolderBrowserDialog();
folderDialog.Description = "Select a root folder for the PDF files to be imported ...";
DialogResult folderResult = folderDialog.ShowDialog();
if (folderResult == DialogResult.OK)
{
sourcePath = folderDialog.SelectedPath;
}
else
{
return;
}
AttachmentAction action = AttachmentAction.Link; //suggested: .Link or .Copy
DirectoryInfo dir = new DirectoryInfo(sourcePath);
List <FileInfo> fileInfos = Path2.GetFilesSafe(dir, "*.pdf", SearchOption.AllDirectories).ToList();
List <Reference> newReferences = new List <Reference>();
SwissAcademic.Citavi.Project activeProject = Program.ActiveProjectShell.Project;
List <string> filePaths = fileInfos.Select <FileInfo, string>(info => info.FullName).ToList();
foreach (string filePath in filePaths)
{
DebugMacro.WriteLine("START IMPORT: " + filePath);
List <Reference> referencesFromFile = new FileImportSupport().ImportFiles(activeProject, activeProject.Engine.TransformerManager, new List <string>()
{
filePath
}, action);
if (referencesFromFile != null && referencesFromFile.Any())
{
var referencesFromFileAdded = activeProject.References.AddRange(referencesFromFile);
var fileName = Path.GetFileName(filePath);
AddCategories(referencesFromFileAdded, filePath.Substring(sourcePath.Length, filePath.Length - sourcePath.Length - fileName.Length));
DebugMacro.WriteLine("SUCCESS");
counter++;
}
else
{
DebugMacro.WriteLine("ERROR importing file");
}
}
} //end try
finally
{
MessageBox.Show(string.Format("Macro has finished execution.\r\n{0} changes were made.", counter.ToString()), "Citavi", MessageBoxButtons.OK, MessageBoxIcon.Information);
} //end finally
} //end main()
/*
// Update is called once per frame
void Update()
{
update_flag = 1;
Rx_MPC1 = Rx_Seen_MPC_Script.seen_MPC1;
Rx_MPC2 = Rx_Seen_MPC_Script.seen_MPC2;
Rx_MPC3 = Rx_Seen_MPC_Script.seen_MPC3;
Tx_MPC1 = Tx_Seen_MPC_Script.seen_MPC1;
Tx_MPC2 = Tx_Seen_MPC_Script.seen_MPC2;
Tx_MPC3 = Tx_Seen_MPC_Script.seen_MPC3;
}
*/
private void FixedUpdate()
{
Rx_MPC1 = Rx_Seen_MPC_Script.seen_MPC1;
Rx_MPC2 = Rx_Seen_MPC_Script.seen_MPC2;
Rx_MPC3 = Rx_Seen_MPC_Script.seen_MPC3;
Tx_MPC1 = Tx_Seen_MPC_Script.seen_MPC1;
Tx_MPC2 = Tx_Seen_MPC_Script.seen_MPC2;
Tx_MPC3 = Tx_Seen_MPC_Script.seen_MPC3;
///////////////////////////////////////////////////////////////////////////////////
/// LOS
///////////////////////////////////////////////////////////////////////////////////
// float startTime = Time.realtimeSinceStartup;
if (!Physics.Linecast(Tx.transform.position, Rx.transform.position))
{
float LOS_distance = (Tx.transform.position - Rx.transform.position).magnitude;
if (LOS_Tracer)
{
Debug.DrawLine(Tx.transform.position, Rx.transform.position, Color.magenta);
}
}
// Debug.Log(((Time.realtimeSinceStartup - startTime) * 1000000f) + "microsec");
///////////////////////////////////////////////////////////////////////////////////
/// MPC1
///////////////////////////////////////////////////////////////////////////////////
List<int> common_mpc1 = new List<int>();
CommonMPC1(Rx_MPC1, Tx_MPC1, out common_mpc1);
List<int> active_MPC1 = new List<int>();
for (int i = 0; i < common_mpc1.Count; i++)
{
// defining peprendicular to the considered normal that is parallel to the ground.
Vector3 n_perp = new Vector3(-MPC1[common_mpc1[i]].Normal.z, 0, MPC1[common_mpc1[i]].Normal.x);
float rx_distance = (Rx.transform.position - MPC1[common_mpc1[i]].Coordinates).magnitude;
float tx_distance = (Rx.transform.position - MPC1[common_mpc1[i]].Coordinates).magnitude;
Vector3 rx_direction = (Rx.transform.position - MPC1[common_mpc1[i]].Coordinates).normalized;
Vector3 tx_direction = (Tx.transform.position - MPC1[common_mpc1[i]].Coordinates).normalized;
if ((Vector3.Dot(n_perp, rx_direction) * Vector3.Dot(n_perp, tx_direction)) < 0)
{
active_MPC1.Add(common_mpc1[i]);
if (MPC1_Tracer)
{
Debug.DrawLine(Rx.transform.position, MPC1[common_mpc1[i]].Coordinates, Color.red);
Debug.DrawLine(Tx.transform.position, MPC1[common_mpc1[i]].Coordinates, Color.blue);
}
}
}
///////////////////////////////////////////////////////////////////////////////////
/// MPC2
///////////////////////////////////////////////////////////////////////////////////
List<Path2> second_order_paths = new List<Path2>();
int brute_force = 1;
for (int i = 0; i < Rx_MPC2.Count; i++)
{
List<GeoComp> temp_list = new List<GeoComp>();
if (brute_force == 1)
{
temp_list = GlobeCom2[Rx_MPC2[i]];
}
else
{
for (int j = 0; j < MPC2.Count; j++)
{
float dist_xxx = (MPC2[j].Coordinates - MPC2[Rx_MPC2[i]].Coordinates).magnitude;
if (dist_xxx < 70)
{
if (!Physics.Linecast(MPC2[j].Coordinates, MPC2[Rx_MPC2[i]].Coordinates))
{
float aod = Mathf.Acos(Vector3.Dot((MPC2[j].Coordinates - MPC2[Rx_MPC2[i]].Coordinates).normalized, MPC2[j].Normal));
float aoa = Mathf.Acos(-Vector3.Dot((MPC2[j].Coordinates - MPC2[Rx_MPC2[i]].Coordinates).normalized, MPC2[Rx_MPC2[i]].Normal));
GeoComp asd = new GeoComp(j, dist_xxx, aod, aoa);
temp_list.Add(asd);
}
}
}
}
for (int ii = 0; ii < Tx_MPC2.Count; ii++)
{
if (temp_list.Any(geocom => geocom.MPCIndex == Tx_MPC2[ii]))
{
int temp_index = temp_list.FindIndex(geocom => geocom.MPCIndex == Tx_MPC2[ii]);
// defining peprendicular to the considered normal that is parallel to the ground.
V6 temp_Rx_MPC2 = MPC2[Rx_MPC2[i]];
V6 temp_Tx_MPC2 = MPC2[Tx_MPC2[ii]];
Vector3 n_perp1 = new Vector3(-temp_Rx_MPC2.Normal.z, 0, temp_Rx_MPC2.Normal.x);
Vector3 Rx_dir1 = (Rx.transform.position - temp_Rx_MPC2.Coordinates).normalized;
Vector3 RT = (temp_Tx_MPC2.Coordinates - temp_Rx_MPC2.Coordinates).normalized;
Vector3 n_perp2 = new Vector3(-temp_Tx_MPC2.Normal.z, 0, temp_Tx_MPC2.Normal.x);
Vector3 Tx_dir2 = (Tx.transform.position - temp_Tx_MPC2.Coordinates).normalized;
Vector3 TR = (temp_Rx_MPC2.Coordinates - temp_Tx_MPC2.Coordinates).normalized;
if ((Vector3.Dot(n_perp1, Rx_dir1) * Vector3.Dot(n_perp1, RT) < 0) && (Vector3.Dot(n_perp2, Tx_dir2) * Vector3.Dot(n_perp2, TR) < 0))
{
float rx_distance2MPC2 = (Rx.transform.position - MPC2[Rx_MPC2[i]].Coordinates).magnitude;
float tx_distance2MPC2 = (Tx.transform.position - MPC2[Tx_MPC2[ii]].Coordinates).magnitude;
float MPC2_distance = temp_list[temp_index].Distance;
float total_distance = rx_distance2MPC2 + MPC2_distance + tx_distance2MPC2;
Path2 temp_path2 = new Path2(Rx.transform.position, MPC2[Rx_MPC2[i]].Coordinates, MPC2[Tx_MPC2[ii]].Coordinates, Tx.transform.position, total_distance, 0.0f);
second_order_paths.Add(temp_path2);
if (MPC2_Tracer)
{
Debug.DrawLine(temp_path2.Rx_Point, temp_path2.MPC2_1, Color.green);
Debug.DrawLine(temp_path2.MPC2_1, temp_path2.MPC2_2, Color.yellow);
Debug.DrawLine(temp_path2.MPC2_2, temp_path2.Tx_Point, Color.cyan);
}
}
}
}
}
}
public static void Main()
{
//reference to the active project and the main window
Form primaryMainForm = Program.ActiveProjectShell.PrimaryMainForm;
if (primaryMainForm == null)
{
return;
}
SwissAcademic.Citavi.Project activeProject = Program.ActiveProjectShell.Project;
if (activeProject == null)
{
return;
}
if (IsBackupAvailable() == false)
{
return; //user wants to backup his/her project first
}
//if no reference filters applied, macro cannot operate
if (Program.ActiveProjectShell.PrimaryMainForm.ReferenceEditorFilterSet.Filters.Count == 0)
{
string message = "This macro requires a selection of references to operate on.\r\n";
message += "Please select some references with PDF files attached.";
MessageBox.Show(message, "Citavi");
return;
}
//path to the current project's CitaviFiles folder
string citaviFilesPath = activeProject.GetFolderPath(CitaviFolder.CitaviFiles);
List <Reference> references = Program.ActiveProjectShell.PrimaryMainForm.GetFilteredReferences();
//List<Reference> references = CollectionUtility.ToList(activeProject.References);
#region Generate list of file locations to move
//first we create a list of files attached to the currently selected references,
//having a PDF extension,
//and existing inside the CitaviFiles folder
List <FileMoveOperation> fileMoveOperations = new List <FileMoveOperation>();
foreach (Reference reference in references)
{
foreach (Location location in reference.Locations)
{
if (location.LocationType != LocationType.ElectronicAddress)
{
continue;
}
if (location.AddressUri.AddressInfo == ElectronicAddressInfo.CitaviFiles)
{
if (Path.GetExtension(location.Address).Equals(".pdf", StringComparison.OrdinalIgnoreCase))
{
FileMoveOperation fileMoveOperation = new FileMoveOperation(location);
fileMoveOperations.Add(fileMoveOperation);
//MessageBox.Show(fileMoveOperation.SourcePath);
//MessageBox.Show(fileMoveOperation.OriginalFileName);
}
}
}
}
if (fileMoveOperations.Count == 0)
{
string message = string.Format("The {0} selected reference(s) do not have any PDF files attached, that are stored inside the CitaviFiles folder.", references.Count);
MessageBox.Show(message, "Citavi");
return;
}
#endregion Generate list of file locations to move
#region Prompt user for target folder to move files to
string targetFolderPath = string.Empty;
using (var folderPicker = new CommonOpenFileDialog())
{
folderPicker.IsFolderPicker = true;
folderPicker.Title = string.Format("Select the folder where you want to move the {0} PDF files to.", fileMoveOperations.Count);
folderPicker.InitialDirectory = Program.Settings.InitialDirectories.GetInitialDirectory(SwissAcademic.Citavi.Settings.InitialDirectoryContext.LocalFile, null);
if (folderPicker.ShowDialog() == CommonFileDialogResult.Ok)
{
targetFolderPath = folderPicker.FileName;
}
else
{
MessageBox.Show("Macro execution cancelled upon user's request.", "Citavi");
return;
}
}
#endregion Prompt user for target folder to move files to
#region Copy the files to the new folder
DirectoryInfo targetDirectory = new DirectoryInfo(targetFolderPath);
foreach (FileMoveOperation fileMoveOperation in fileMoveOperations)
{
//avoid overwriting a possible existing file
fileMoveOperation.TargetPath = Path2.GetUniqueFilePath(targetDirectory, fileMoveOperation.OriginalFileName);
try
{
File.Copy(fileMoveOperation.SourcePath, fileMoveOperation.TargetPath, false);
fileMoveOperation.CopySuccess = true;
}
catch (Exception exception)
{
fileMoveOperation.Errors.Add(exception);
fileMoveOperation.CopySuccess = false;
}
}
#endregion Copy the files to the new region
#region Relink each reference to the new files
foreach (FileMoveOperation fileMoveOperation in fileMoveOperations)
{
if (fileMoveOperation.CopySuccess)
{
try
{
fileMoveOperation.TargetLocation = fileMoveOperation.SourceLocation.Reference.Locations.Add(LocationType.ElectronicAddress, fileMoveOperation.TargetPath, string.Empty, false);
fileMoveOperation.TargetLocation.Notes = fileMoveOperation.SourceLocation.Notes;
fileMoveOperation.RelinkSuccess = true;
}
catch (Exception exception)
{
fileMoveOperation.Errors.Add(exception);
fileMoveOperation.RelinkSuccess = false;
}
}
}
#endregion Relink each reference to the new files
#region Delete the original locations and move the files in the CitaviFiles folder to CitaviFiles\RecycleBin
foreach (FileMoveOperation fileMoveOperation in fileMoveOperations)
{
if (fileMoveOperation.RelinkSuccess)
{
try
{
Location locationToDelete = fileMoveOperation.SourceLocation;
Project locationProject = locationToDelete.Project;
if (locationToDelete == null)
{
continue;
}
ElectronicAddressUri addressUriToDelete = locationToDelete.AddressUri;
locationToDelete.Reference.Locations.Remove(locationToDelete);
Program.ActiveProjectShell.Save(primaryMainForm);
DirectoryInfo recycleBinDirectory = new DirectoryInfo(locationProject.GetFolderPath(CitaviFolder.RecycleBin));
string deletedFilePath = Path2.GetUniqueFilePath(recycleBinDirectory, fileMoveOperation.OriginalFileName);
File.Move(fileMoveOperation.SourcePath, deletedFilePath);
fileMoveOperation.DeleteSuccess = true;
}
catch (Exception exception)
{
fileMoveOperation.Errors.Add(exception);
fileMoveOperation.DeleteSuccess = false;
}
}
}
#endregion Delete the original locations and move the files in the CitaviFiles folder to CitaviFiles\RecycleBin
MessageBox.Show("Macro has finished execution.", "Citavi");
}
private void btnAddFilePath_Click(object sender, EventArgs e)
{
try
{
btnPrimaryDir.BackColor = Color.FromName("Control");
btnSecondDir.BackColor = Color.FromName("Control");
btnAddFilePath.BackColor = Color.FromName("Control");
string Path1;
string Path2;
if (rbPrimaryDir.Checked)
{
if (textBox2.Text == "")
{
rbSecondaryDir.BackColor = Color.Yellow;
btnSecondDir.BackColor = Color.Yellow;
}
rbPrimaryDir.BackColor = Color.FromName("Control");
tvFilesView.SelectedNode.BackColor = Color.Blue;
tvFilesView.SelectedNode.ForeColor = Color.White;
if (tvFilesView.SelectedNode.PrevNode != null || tvFilesView.SelectedNode.PrevNode.BackColor == Color.Green ||
tvFilesView.SelectedNode.PrevNode.BackColor == Color.Blue)
{
tvFilesView.SelectedNode.PrevNode.BackColor = Color.White;
tvFilesView.SelectedNode.PrevNode.ForeColor = Color.Black;
}
Path1 = tvFilesView.SelectedNode.FullPath.ToString();
Path1 = Path1.Insert(1, ":");
textBox1.Text = Path1;
}
else if (rbSecondaryDir.Checked)
{
if (textBox1.Text == "")
{
rbPrimaryDir.BackColor = Color.Yellow;
btnPrimaryDir.BackColor = Color.Yellow;
}
rbSecondaryDir.BackColor = Color.FromName("Control");
rbSecondaryDir.BackColor = Color.Transparent;
tvFilesView.SelectedNode.BackColor = Color.Green;
tvFilesView.SelectedNode.ForeColor = Color.White;
if (tvFilesView.SelectedNode.PrevNode != null || tvFilesView.SelectedNode.PrevNode.BackColor == Color.Blue ||
tvFilesView.SelectedNode.PrevNode.BackColor == Color.Green)
{
tvFilesView.SelectedNode.PrevNode.BackColor = Color.White;
tvFilesView.SelectedNode.PrevNode.ForeColor = Color.Black;
}
Path2 = tvFilesView.SelectedNode.FullPath.ToString();
Path2 = Path2.Insert(1, ":");
textBox2.Text = Path2;
}
else
{
tbOutPut.Text = "Pick two Directories to begin!";
errorProvider.SetError(rbPrimaryDir, "Select One");
errorProvider.SetError(rbSecondaryDir, "Select One");
errorProvider.SetError(btnPrimaryDir, "Select a Directory");
errorProvider.SetError(btnSecondDir, "Select a Directory");
}
Path1 = textBox1.Text;
Path2 = textBox2.Text;
if (Path1 != "" && Path2 != "")
{
btnCompare.BackColor = Color.Yellow;
tbOutPut.Text = "Green Light to compare Files !";
tbOutPut.BackColor = Color.Green;
tbOutPut.ForeColor = Color.White;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public static async Task SendByEMailAsync(this Reference reference, MainForm mainForm)
{
var mailTemplate = new MailTemplate();
var attachmentFileNames = new StringBuilder();
foreach (var location in reference.Locations.GetAvailable())
{
var fileInfo = new FileInfo(location.Address.Resolve().GetLocalPathSafe());
mailTemplate.Attachments.Add(fileInfo.FullName);
attachmentFileNames.AppendLine(fileInfo.Name);
}
var shortTitle = (string.IsNullOrEmpty(reference.ShortTitle)
? SendReferenceByEmailResources.ShortTitleMissing
: reference.ShortTitle).UnciodeToLatin();
mailTemplate.Subject = "Citavi: " + shortTitle;
var stringBuilder = new StringBuilder();
foreach (var c in shortTitle)
{
if (c < 32 || c > 254)
{
continue;
}
stringBuilder.Append(c);
if (stringBuilder.Length > 50)
{
break;
}
}
shortTitle = Path2.GetValidFileName(stringBuilder.ToString());
var risTempFileName = Path.Combine(Path.GetTempPath(), shortTitle + ".ris");
var risExportDataExchangeProptery = new FileExportDataExchangeProperty
{
FileName = risTempFileName,
ExportReferences = new List <Reference>()
{
reference
},
Transformer = Program.Engine.TransformerManager.GetById(Transformer.RISTransformerId)
};
var exporter = new Exporter();
var success = false;
using (var fs = File.OpenWrite(risTempFileName))
{
success = await exporter.RunAsync(risExportDataExchangeProptery, fs, CancellationToken.None, null);
}
if (!success)
{
return;
}
mailTemplate.Attachments.Add(risTempFileName);
attachmentFileNames.AppendLine(Path.GetFileName(risTempFileName));
mailTemplate.Body = mailTemplate.Attachments.Count > 0
? string.Format(SendReferenceByEmailResources.SendReferenceByEMailBodyText_WithAttachments, reference.Project.Name, reference.ToString(TextFormat.Text), attachmentFileNames.ToString())
: string.Format(SendReferenceByEmailResources.SendReferenceByEMailBodyText, reference.Project.Name, reference.ToString(TextFormat.Text));
try
{
Outlook.Send(mailTemplate);
}
catch (System.Runtime.InteropServices.COMException)
{
MessageBox.Show(mainForm, SendReferenceByEmailResources.OutlookRightsMessage, mainForm.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
void TxtPath_TextChanged(object sender, EventArgs e) => lblEnvironmentFullPath.Text = Path2.GetFullPathFromPathWithVariables(txtPath.Text);
CreateDescriptor(Path2, PipFragmentType.AbsolutePath, f => f.GetPathValue(), (v, p) => p.Add(v)),
// Methods
public override void OnBeforePerformingCommand(MainForm mainForm, BeforePerformingCommandEventArgs e)
{
e.Handled = true;
var container = _containers.FirstOrDefault(c => c.MainForm.Equals(mainForm));
switch (e.Key)
{
case ButtonKey_ShowMacroEditor:
{
GetOrCreateMacroEditorForm(false, out bool _, out bool _).Activate();
}
break;
case ButtonKey_Refresh:
{
UpdateTools(container);
}
break;
case ButtonKey_Configurate:
{
using (var directoryDialog = new DirectoryForm(mainForm, Settings.TryGetStringValue(SettingsKey)))
{
if (directoryDialog.ShowDialog() == DialogResult.OK)
{
if (!directoryDialog.Directory.Equals(Settings.TryGetStringValue(SettingsKey), StringComparison.OrdinalIgnoreCase))
{
Settings[SettingsKey] = directoryDialog.Directory;
Program.Settings.InitialDirectories.SetInitialDirectoryContext(Citavi.Settings.InitialDirectoryContext.Macros, Path2.GetFullPathFromPathWithVariables(directoryDialog.Directory));
UpdateTools(container);
}
}
}
}
break;
case ButtonKey_OpenInExplorer:
{
if (IsValidDirectory(out string message))
{
var path = Path2.GetFullPathFromPathWithVariables(Settings[SettingsKey]);
Process.Start("explorer.exe", path);
}
else
{
MessageBox.Show(mainForm, message, mainForm.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
break;
default:
if (e.Key.StartsWith(ButtonKey, StringComparison.OrdinalIgnoreCase))
{
if (container.Macros.ContainsKey(e.Key))
{
var macro = container.Macros[e.Key];
if (File.Exists(macro.Path))
{
var hide = macro.Action == MacroAction.Run;
var editor = GetOrCreateMacroEditorForm(hide, out bool hidden, out bool isNew);
if (!isNew && editor.IsDirty())
{
if (MessageBox.Show(mainForm, Properties.Resources.UserWarningSaveMessage, mainForm.ProductName, MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
{
editor.Save();
}
}
editor.MacroCode = File.ReadAllText(macro.Path);
editor.SetFilePath(macro.Path);
editor.Activate();
if (macro.Action == MacroAction.Run)
{
editor.Run();
}
if (hidden)
{
editor.Close();
}
}
else
{
MessageBox.Show(mainForm, Properties.Resources.PathNotFoundMessage.FormatString(macro.Path), mainForm.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
UpdateTools(container, true);
}
}
else
{
e.Handled = false;
}
}
else
{
e.Handled = false;
}
break;
}
}
public void Execute(int index)
{
OutputDelays[index] = 0;
OutputAmplitudes[index] = 0;
V6 level1 = SeenMPC2Table[Rx_MPC2Array[index]];
float distance1 = (level1.Coordinates - Rx_Position).magnitude;
int temp_index = Mathf.FloorToInt(index / MaxListsLength);
int temp_i = index - temp_index * MaxListsLength;
if (temp_i <= LookUpTable2ID[Rx_MPC2Array[index]].y - LookUpTable2ID[Rx_MPC2Array[index]].x)
{
int temp_l = LookUpTable2ID[Rx_MPC2Array[index]].x + temp_i;
V6 level2 = SeenMPC2Table[LookUpTable2[temp_l].MPCIndex];
Vector3 level2_to_level1 = (level1.Coordinates - level2.Coordinates).normalized;
float distance2 = (level1.Coordinates - level2.Coordinates).magnitude;
// check if level2 is seen by Tx
int existence_flag = 0;
float Tx_att = 0f;
for (int i = 0; i < Tx_MPC2.Length; i++)
{
if (LookUpTable2[temp_l].MPCIndex == Tx_MPC2[i])
{
existence_flag = 1;
Tx_att = Tx_MPC2_att[i];
break;
}
}
if (existence_flag == 1)
{
Vector3 normal1 = level1.Normal;
Vector3 n_perp1 = new Vector3(-normal1.z, 0, normal1.x);
Vector3 Rx_to_level1 = (level1.Coordinates - Rx_Position).normalized;
Vector3 normal2 = level2.Normal;
Vector3 n_perp2 = new Vector3(-normal2.z, 0, normal2.x);
Vector3 level2_to_Tx = (Tx_Position - level2.Coordinates).normalized;
// check if the two vectors come from different sides of the normal
if ((Vector3.Dot(n_perp2, level2_to_level1) * Vector3.Dot(n_perp2, level2_to_Tx) < 0) && (Vector3.Dot(n_perp1, level2_to_level1) * Vector3.Dot(n_perp1, Rx_to_level1) < 0))
{
double theta11 = Math.Acos(Vector3.Dot(normal1, -Rx_to_level1));
double theta12 = Math.Acos(Vector3.Dot(normal1, -level2_to_level1));
int I11, I12, I13;
if (theta11 + theta12 < 0.35)
{
I11 = 0;
}
else
{
I11 = 1;
}
if (theta11 < 1.22)
{
I12 = 0;
}
else
{
I12 = 1;
}
if (theta12 < 1.22)
{
I13 = 0;
}
else
{
I13 = 1;
}
float angular_gain1 = (float)Math.Exp(-12 * ((theta11 + theta12 - 0.35) * I11 + (theta11 - 1.22) * I12 + (theta12 - 1.22) * I13));
double theta21 = Math.Acos(Vector3.Dot(normal2, level2_to_Tx));
double theta22 = Math.Acos(Vector3.Dot(normal1, level2_to_level1));
int I21, I22, I23;
if (theta21 + theta22 < 0.35)
{
I21 = 0;
}
else
{
I21 = 1;
}
if (theta21 < 1.22)
{
I22 = 0;
}
else
{
I22 = 1;
}
if (theta22 < 1.22)
{
I23 = 0;
}
else
{
I23 = 1;
}
float angular_gain2 = (float)Math.Exp(-12 * ((theta21 + theta22 - 0.35) * I21 + (theta21 - 1.22) * I22 + (theta22 - 1.22) * I23));
float angular_gain = angular_gain1 * angular_gain2;
float distance3 = level2_to_Tx.magnitude;
float distance = distance1 + distance2 + distance3;
Path2 temp_path2 = new Path2(Rx_Position, level1.Coordinates, level2.Coordinates, Tx_Position, distance, angular_gain);
SecondOrderPaths[index] = temp_path2;
OutputDelays[index] = distance;// / Speed_of_Light;
OutputAmplitudes[index] = Tx_att * Rx_MPC2Array_att[index] * angular_gain * (float)Math.Pow(1 / distance, 2);
}
}
}
}
static void Main(string[] args)
{
/*
*
*/
CommandLine options = new CommandLine();
if (options.Parse(args) == false)
{
Environment.Exit(1001);
return;
}
if (options.Help == true)
{
options.HelpShow();
Environment.Exit(1002);
return;
}
_options = options;
/*
*
*/
string[] files = Yttrium.Glob.Do(options.FilePatterns.ToArray());
if (files == null || files.Length == 0)
{
Console.WriteLine("error: no matching files.");
Environment.Exit(2);
}
/*
*
*/
Console.WriteLine("~ mode: '{0}'", _options.Mode);
/*
*
*/
Microsoft.Office.Interop.Visio.Application visio = null;
bool anyError = false;
try
{
/*
*
*/
ModelExporter exporter = new ModelExporter();
exporter.PageStart += new EventHandler <PageEventArgs>(OnPageStart);
exporter.PageEnd += new EventHandler <PageEventArgs>(OnPageEnd);
exporter.StepStart += new EventHandler <PageStepEventArgs>(OnStepStart);
exporter.StepEnd += new EventHandler <PageStepEventArgs>(OnStepEnd);
/*
*
*/
visio = new Microsoft.Office.Interop.Visio.Application();
visio.AlertResponse = 1;
visio.Visible = false;
foreach (string file in files)
{
/*
*
*/
Console.Write("+ opening '{0}'...", Path2.RelativePath(file));
FileInfo fileInfo = new FileInfo(file);
if (fileInfo.Exists == false)
{
ConsoleFail();
Console.WriteLine(" - file does not exist");
anyError = true;
continue;
}
/*
* Open the document: if the document is not a valid/compatible Visio
* document, this will fail.
*/
Microsoft.Office.Interop.Visio.Document document;
try
{
document = visio.Documents.Open(fileInfo.FullName);
ConsoleOk();
}
catch (Exception ex)
{
ConsoleFail();
if (options.Verbose == true)
{
ConsoleDump(ex);
}
anyError = true;
continue;
}
/*
* Settings
*/
ModelExportSettings exportSettings = new ModelExportSettings();
exportSettings.Program = "ModelExport";
exportSettings.Mode = options.Mode;
exportSettings.Path = options.OutputDirectory ?? fileInfo.DirectoryName;
exporter.Settings = exportSettings;
/*
* Export.
*/
ModelCommandResult result = null;
ModelCommand command = new ModelCommand();
command.Document = document;
command.Operation = ModelOperation.ExportAll;
if (options.ValidateOnly == true)
{
command.Operation = ModelOperation.ValidateAll;
}
try
{
result = exporter.Execute(command);
}
catch (Exception ex)
{
anyError = true;
if (options.Verbose == true)
{
ConsoleDump(ex);
}
}
finally
{
document.Close();
}
if (result == null)
{
continue;
}
/*
*
*/
Console.WriteLine("");
Console.WriteLine("execution summary");
Console.WriteLine("-------------------------------------------------------------------------");
foreach (ModelCommandPageResult pageResult in result.Pages)
{
Console.Write(pageResult.Name);
if (pageResult.Success == true)
{
ConsoleOk();
}
else
{
ConsoleFail();
}
foreach (ModelResultItem item in pageResult.Items)
{
string marker;
switch (item.ItemType)
{
case ModelResultItemType.Error:
Console.ForegroundColor = ConsoleColor.DarkRed;
marker = "!";
break;
case ModelResultItemType.Warning:
Console.ForegroundColor = ConsoleColor.DarkYellow;
marker = "W";
break;
default:
marker = " ";
break;
}
if (item.VisioShapeId == null)
{
Console.WriteLine("{0} [page] {1}#{2}: {3}", marker, item.Actor, item.Code, item.Description);
}
else
{
Console.WriteLine("{0} [{1}] {2}#{3}: {4}", marker, item.VisioShapeId, item.Actor, item.Code, item.Description);
}
Console.ResetColor();
}
}
}
}
catch (Exception ex)
{
ConsoleDump(ex);
}
finally
{
// This _needs_ to be performed here: in case an exception is caught,
// make sure that Visio is closed or otherwise a zombie process will
// be left running on the machine.
if (visio != null)
{
visio.Quit();
}
}
/*
*
*/
if (anyError == true)
{
Environment.Exit(3);
}
else
{
Environment.Exit(0);
}
}
