/// <summary>
/// Fills the available command buffer with the current available options.
/// </summary>
public static void UpdateCommandBuffer()
{
var references = DataHolder.GUIReferences;
var data = DataHolder.TerminalData;
SList.Clear(data.AvailableCommands);
var currentText = references.Input.value;
var programName = CommandLineUtil.GetCommandName(currentText);
var program = Shell.FindProgramByCommand(programName);
Action bufferFiller;
if (program == null)
{
bufferFiller = null;
}
else
{
bufferFiller = Shell.GetProgramBufferFillerMethod(program);
}
if (bufferFiller == null)
{
FileSystem.FilleCommandBufferWithFileSystem(FillBufferFileSystemOptions.IncludeAll);
}
else
{
bufferFiller();
}
ChangeToAvailableCommandsBuffer();
}
public static void CachePanels(WindowComponent windowComponent)
{
SList.Clear(windowComponent.Panels);
var panels = windowComponent.gameObject.GetComponentsInChildren <UIPanel>(true);
for (int i = 0; i < panels.Length; i++)
{
var panel = panels[i];
SList.Add(windowComponent.Panels, panel);
}
}
public static void CacheWidgets(WindowComponent windowComponent)
{
SList.Clear(windowComponent.Widgets);
var widgets = windowComponent.gameObject.GetComponentsInChildren <UIWidget>(true);
for (int i = 0; i < widgets.Length; i++)
{
var widget = widgets[i];
SList.Add(windowComponent.Widgets, widget);
}
}
/// <summary>
/// Returns a list containing all of the dir files.
/// </summary>
public static void CacheDirFiles(HashDir dir)
{
SList.Clear(dir.Files);
for (int i = 0; i < dir.FilesId.Count; i++)
{
var fileId = dir.FilesId[i];
var file = FindFileById(fileId);
DebugUtil.Assert(file == null, string.Format("THE DIR {0} HAS A INVALID FILE {1}", dir.Name, fileId));
file.ParentDirId = dir.DirId;
file.ParentDir = dir;
SList.Add(dir.Files, file);
}
}
/// <summary>
/// Cache the dirs children based on the ChildsDirid values.
/// </summary>
public static void CacheDirChildren(HashDir dir)
{
SList.Clear(dir.Childs);
for (int i = 0; i < dir.ChildsDirId.Count; i++)
{
var childId = dir.ChildsDirId[i];
var child = FindDirById(childId);
DebugUtil.Assert(child == null, string.Format("THE DIR {0} HAS A INVALID CHILD {1}", dir.Name, childId));
child.ParentDirId = dir.DirId;
child.ParentDir = dir;
SList.Add(dir.Childs, child);
}
}
/// <summary>
/// Calculates and return the full path of the dir.
/// </summary>
public static string GetDirFullPath(HashDir hashDir)
{
var dir = hashDir;
string path;
// Root folder is treated differently
if (dir.ParentDirId == -1)
{
DebugUtil.Assert(dir.Name != PathUtil.PathSeparator, string.Format("THE DIR {0} HAS NO PARENT AND IT'S THE ROOT DIR!", dir.DirId));
path = dir.Name;
}
else
{
#if DEB
if (dir.ParentDirId == dir.DirId)
{
DebugUtil.Log(string.Format("THE DIR {0} HAS ITSELF AS PARENT!", dir.DirId), Color.red, DebugUtil.DebugCondition.Always,
DebugUtil.LogType.Info);
return(null);
}
#endif
var pathStack = SList.Create <string>(5);
SList.Clear(pathStack);
while (dir.ParentDirId != -1)
{
SList.Push(pathStack, dir.Name);
dir = FindDirById(dir.ParentDirId);
}
var builder = new StringBuilder(pathStack.Count * 10);
while (pathStack.Count > 0)
{
var last = SList.Pop(pathStack);
builder.Append(PathUtil.AddSeparatorToStart(last));
}
path = builder.ToString();
// since it's a folder, add slash to the end of it
path = PathUtil.AddSeparatorToEnd(path);
}
return(path);
}
public static void FilleCommandBufferWithFileSystem(FillBufferFileSystemOptions option)
{
var commandBuffer = DataHolder.TerminalData.AvailableCommands;
var data = DataHolder.DeviceData.CurrentDevice.FileSystem;
SList.Clear(commandBuffer);
var currentDir = data.CurrentDir;
if (option == FillBufferFileSystemOptions.IncludeAll || option == FillBufferFileSystemOptions.IncludeDir)
{
if (currentDir.ParentDir != null)
{
SList.Add(commandBuffer, "..");
}
SList.Add(commandBuffer, ".");
var childs = GetAllAvailableChild(currentDir);
for (int i = 0; i < childs.Count; i++)
{
SList.Add(commandBuffer, childs[i].FullPath);
}
}
if (option == FillBufferFileSystemOptions.IncludeAll || option == FillBufferFileSystemOptions.IncludeFile)
{
var files = GetAvailableFilesFromDir(currentDir);
for (int i = 0; i < files.Count; i++)
{
SList.Add(commandBuffer, files[i].FullPath);
}
}
TerminalUtil.ChangeToAvailableCommandsBuffer();
}
/// <summary>
/// Sets value referenced by path.
/// </summary>
/// <param name="target">The relative object for which to set the value.</param>
/// <param name="value">The value to set on an object along the expression path.</param>
/// <param name="parameters">Optional parameters for substitution; if a parameter value is null is will be populated with the created instance.</param>
public void SetValue(object target, object value, Dictionary <string, object> parameters)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
if (this.m_type == null)
{
return;
}
if (this.m_property == null)
{
return;
}
if (!this.m_type.IsInstanceOfType(target))
{
throw new ArgumentException("target is not an instance of the expected type.", "target", null);
}
try
{
object thisvalue = this.m_property.GetValue(target, null);
if (this.m_property.PropertyType.IsGenericType &&
typeof(IEnumerable).IsAssignableFrom(this.m_property.PropertyType) &&
IsEntityType(this.m_property.PropertyType.GetGenericArguments()[0]))
{
IEnumerable list = (IEnumerable)thisvalue;
object colitem = null;
foreach (object eachelem in list)
{
// derived class may have its own specific property (e.g. IfcSIUnit, IfcConversionBasedUnit)
if (this.m_identifier != null)
{
// find of specific identifier
Type eachtype = eachelem.GetType();
PropertyInfo propElem = GetPropertyDefault(eachtype);
if (propElem != null)
{
object eachname = propElem.GetValue(eachelem, null);
if (this.m_identifier.StartsWith("@"))
{
// find by parameter
if (parameters != null && parameters.TryGetValue(this.m_identifier.Substring(1), out colitem))
{
break;
}
}
else if (eachname != null && this.m_identifier.Equals(eachname.ToString()))
{
// yes -- drill in
colitem = eachelem;
break;
}
}
}
else if (this.m_inner != null)
{
// find first that matches type
if (this.m_inner.Type == null || this.m_inner.Type.IsInstanceOfType(eachelem))
{
colitem = eachelem;
break;
}
}
else
{
// find first
colitem = eachelem;
break;
}
}
// now tunnel through
if (this.m_inner != null)
{
if (colitem == null && this.m_inner.Type != null)
{
if (colitem == null)
{
colitem = Activator.CreateInstance(this.m_inner.Type);
// name the object
if (this.m_identifier != null)
{
if (this.m_identifier.StartsWith("@") && parameters != null)
{
// record parameter
string paramname = this.m_identifier.Substring(1);
parameters[paramname] = colitem;
}
else
{
PropertyInfo propDefault = GetPropertyDefault(this.m_inner.Type);
if (propDefault != null)
{
propDefault.SetValue(colitem, value);
}
}
}
}
else if (this.m_property.PropertyType.IsClass &&
this.m_property.PropertyType.IsGenericType &&
(this.m_property.PropertyType.GetGenericTypeDefinition() == typeof(ISet <>) || this.m_property.PropertyType.GetGenericTypeDefinition() == typeof(IList <>)))
{
CollectionAdd(list, colitem);
}
}
if (colitem != null)
{
this.m_inner.SetValue(colitem, value, parameters);
}
}
else
{
// reference to an existing object
if (list.GetType().GetGenericArguments()[0].IsInstanceOfType(value))
{
if (!CollectionContains(list, value))
{
CollectionAdd(list, value);
}
}
}
}
else if (this.m_inner != null)
{
// must allocate
if (thisvalue == null && this.m_inner.Type != null)
{
Type convtype = this.m_inner.Type;
if (convtype.IsValueType)
{
// convert type if type converter is defined
if (convtype.IsDefined(typeof(TypeConverterAttribute), true))
{
TypeConverterAttribute attr = (TypeConverterAttribute)convtype.GetCustomAttributes(typeof(TypeConverterAttribute), true)[0];
Type typeconv = Type.GetType(attr.ConverterTypeName);
if (typeconv != null)
{
TypeConverter converter = (TypeConverter)Activator.CreateInstance(typeconv);
value = converter.ConvertFrom(value);
this.Property.SetValue(target, value);
}
}
}
else
{
if (thisvalue == null)
{
// get type from inner token
thisvalue = Activator.CreateInstance(this.m_inner.Type);
}
this.Property.SetValue(target, thisvalue);
}
}
if (IsEntity(thisvalue))
{
this.m_inner.SetValue(thisvalue, value, parameters);
}
}
else
{
// get type converter, set value
Type convtype = this.Property.PropertyType;
if (convtype.IsInstanceOfType(value))
{
// set field instead to avoid perf hit
this.Property.SetValue(target, value);
}
#if false
else if (convtype == typeof(IList <IfcLabel>))
{
// address lines
if (value != null)
{
SList <IfcLabel> listlabel = (SList <IfcLabel>) this.Field.GetValue(target);
listlabel.Clear();
string strval = value.ToString();
string[] parts = strval.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string part in parts)
{
listlabel.Add(new IfcLabel(part));
}
}
}
#endif
else
{
// value
if (convtype.IsGenericType && convtype.GetGenericTypeDefinition() == typeof(Nullable <>))
{
// special case for Nullable types
convtype = convtype.GetGenericArguments()[0];
}
// convert type if type converter is defined
if (convtype.IsDefined(typeof(TypeConverterAttribute), true))
{
TypeConverterAttribute attr = (TypeConverterAttribute)convtype.GetCustomAttributes(typeof(TypeConverterAttribute), true)[0];
Type typeconv = Type.GetType(attr.ConverterTypeName);
if (typeconv != null)
{
TypeConverter converter = (TypeConverter)Activator.CreateInstance(typeconv);
value = converter.ConvertFrom(value);
this.Property.SetValue(target, value);
}
}
else
{
// log warning
System.Diagnostics.Debug.WriteLine("CvtValuePath::SetValue() - " + this.ToString() + " - " + convtype.Name + " has no type converter defined.");
}
}
}
}
catch (Exception e)
{
// log it...
System.Diagnostics.Debug.WriteLine("CvtValuePath::SetValue exception: " + e.ToString());
}
}
