/// <summary> Load a data var as its restored as part of a project </summary>
/// <param name="dvs"></param>
/// <param name="index">index within the collection of dataVarUIHandlers at which to place the data var</param>
/// <param name="newDataVar"></param>
/// <returns></returns>
public bool LoadDataVarFromStorage(DataVarStorage dvs, out DataVariable newDataVar)
{
//NOTE - probably will need to improve this for x-plat needs, although maybe not
// since path is stored from local path anyway
string path = dvs.pathOnly + "\\" + dvs.filename;
string errorMsg;
newDataVar = null;
//make sure the file exists, so we can give a simpler error than we'd get otherwise when calling LoadAddFile
if (!File.Exists(path))
{
UIManager.I.ShowMessageDialog("File not found: " + path);
return(false);
}
//Actually load it now
if (!DataManager.I.LoadAddFile(path, dvs.hasRowHeaders, dvs.hasColumnHeaders, out newDataVar, out errorMsg))
{
UIManager.I.ShowMessageDialog("Loading data failed.\n" + path + "\n" + errorMsg);
return(false);
}
newDataVar.Label = dvs.label;
DataVarUIHandler.SetDataVarAtIndex(newDataVar, dvs.UIindex);
return(true);
}
private DataVariable LoadDataVariable(XmlNode inputNode)
{
var ddiValue = inputNode.GetXmlNodeValue("@A");
if (string.IsNullOrEmpty(ddiValue))
{
return(null);
}
var ddi = Convert.ToInt32(ddiValue, 16);
long dataValue;
if (!inputNode.GetXmlNodeValue("@B").ParseValue(out dataValue))
{
dataValue = 0;
}
var userUnit = _taskDocument.Units.FindById(inputNode.GetXmlNodeValue("@E"));
var unit = UnitFactory.Instance.GetUnitByDdi(ddi);
var dataVariable = new DataVariable
{
Ddi = ddi,
Value = unit.ConvertFromIsoUnit(dataValue),
ProductId = inputNode.GetXmlNodeValue("@C"),
IsoUnit = unit,
UserUnit = userUnit.ToAdaptUnit()
};
return(dataVariable);
}
/// <summary>
/// Load a file path into a DataVariable. Does NOT add it to the DataManager
/// </summary>
/// <param name="hasRowHeaders">Flag. Set if data file is expected to have row headers.</param>
/// <param name="hasColumnHeaders">Flag. Set if data file is expected to have column headers.</param>
/// <param name="dataVariable">Returns a new DataVariable. Is valid but empty object if error or canceled.</param>
/// <param name="errorMsg">Contains an error message on failure.</param>
/// <returns>True on success. False if user cancels file picker or if there's an error.</returns>
public bool LoadFile(string path, bool hasRowHeaders, bool hasColumnHeaders, out DataVariable dataVariable, out string errorMsg)
{
dataVariable = new DataVariable();
//foreach (string s in path)
// Debug.Log(s);
bool success = false;
errorMsg = "No Error";
//Cast to base class for reading in the file
CSVReaderData data = (CSVReaderData)dataVariable; // new CSVReaderData();
try
{
success = CSVReader.Read(path, hasColumnHeaders, hasRowHeaders, ref data, out errorMsg);
}
catch (Exception e)
{
errorMsg = "Exception caught: " + e.ToString();
Debug.Log(errorMsg);
return(false);
}
if (success)
{
dataVariable.Filepath = path;
}
else
{
Debug.Log("Error msg from csv read: \n");
Debug.Log(errorMsg);
}
return(success);
}
private void AddDataVariable(TreatmentZone treatmentZone, NumericRepresentationValue value, string productId, IsoUnit unit)
{
if (value != null && value.Value != null)
{
var targetValue = value.Value.Value;
// Convert input value to Iso unit
var adaptUnit = unit.ToAdaptUnit();
UnitOfMeasure userUnit = null;
if (adaptUnit != null && value.Value.UnitOfMeasure != null &&
adaptUnit.Dimension == value.Value.UnitOfMeasure.Dimension)
{
userUnit = value.Value.UnitOfMeasure;
targetValue = _unitConverter.Convert(userUnit.ToInternalUom(), adaptUnit.ToInternalUom(), targetValue);
}
var dataVariable = new DataVariable
{
ProductId = productId,
Value = targetValue,
IsoUnit = unit,
UserUnit = userUnit
};
treatmentZone.Variables.Add(dataVariable);
}
}
/// <summary> Remove and clear/empty/delete a data var </summary>
/// <param name="var"></param>
public void Remove(DataVariable var)
{
if (var == null)
{
return;
}
if (variables.Contains(var))
{
variables.Remove(var);
//Remove possible variable mapping
foreach (Mapping mapping in Enum.GetValues(typeof(Mapping)))
{
if (variableMappings[(int)mapping] == var)
{
variableMappings[(int)mapping] = null;
}
}
var.Clear();
}
else
{
Debug.LogWarning("Tried removing variable that's not in variable list.");
}
//Update UI
UIManager.I.RefreshUI();
}
private void Init(DataVariable dv)
{
pathOnly = Path.GetDirectoryName(dv.Filepath);
filename = Path.GetFileName(dv.Filepath);
label = dv.Label;
mappings = new List <DataManager.Mapping>();
hasRowHeaders = dv.hasRowHeaders;
hasColumnHeaders = dv.hasColumnHeaders;
if (dv.UIhandler != null)
{
UIindex = dv.UIhandler.UIindex;
}
//Find which mappings this is assigned to
if (DataManager.I.GetVariableByMapping(DataManager.Mapping.Height) == dv)
{
mappings.Add(DataManager.Mapping.Height);
}
if (DataManager.I.GetVariableByMapping(DataManager.Mapping.TopColor) == dv)
{
mappings.Add(DataManager.Mapping.TopColor);
}
if (DataManager.I.GetVariableByMapping(DataManager.Mapping.SideColor) == dv)
{
mappings.Add(DataManager.Mapping.SideColor);
}
}
private DataVariable LoadDataVariable(XmlNode inputNode)
{
var ddiValue = inputNode.GetXmlNodeValue("@A");
if (string.IsNullOrEmpty(ddiValue))
return null;
var ddi = Convert.ToInt32(ddiValue, 16);
long dataValue;
if (!inputNode.GetXmlNodeValue("@B").ParseValue(out dataValue))
dataValue = 0;
var userUnit = _taskDocument.Units.FindById(inputNode.GetXmlNodeValue("@E"));
var unit = UnitFactory.Instance.GetUnitByDdi(ddi);
var dataVariable = new DataVariable
{
Ddi = ddi,
Value = unit.ConvertFromIsoUnit(dataValue),
ProductId = inputNode.GetXmlNodeValue("@C"),
IsoUnit = unit,
UserUnit = userUnit.ToAdaptUnit()
};
return dataVariable;
}
public void DebugDumpVariables(bool verbose)
{
Debug.Log("============= Variable Mappings: ");
foreach (Mapping mapping in Enum.GetValues(typeof(Mapping)))
{
DataVariable var = variableMappings[(int)mapping];
string label = var == null ? "unassigned" : var.Label; //Note - make this string separately instead of directly in the Debug.Log call below, or else seems to evaluate both options of the ? operator and then fails
Debug.Log(Enum.GetName(typeof(Mapping), mapping) + ": " + label);
}
Debug.Log("------------------------------");
Debug.Log("Dumping data variable headers: ");
foreach (DataVariable var in variables)
{
if (verbose)
{
var.DumpMetaData();
}
else
{
Debug.Log("Label: " + var.Label);
}
if (verbose)
{
Debug.Log("------------------------------");
}
}
Debug.Log("=============================== end");
}
//Encrypt / Decrypt
private void toolStripButton3_Click(object sender, EventArgs e)
{
if (DataVarList.Count > 0)
{
if (!DataVarList[FileTabs.SelectedIndex].Encrypted)
{
if (DataVarList[FileTabs.SelectedIndex].Tabs.Text != "")
{
Save_Open__File Save_Open = new Save_Open__File(DataVarList, Source);
string _string =
Save_Open.Encrypt(DataVarList[FileTabs.SelectedIndex].Tabs.Rtf);
DataVarList[FileTabs.SelectedIndex].Tabs.WordWrap = true;
DataVarList[FileTabs.SelectedIndex].Tabs.Text = _string;
DataVarList[FileTabs.SelectedIndex].Tabs.SelectAll();
DataVarList[FileTabs.SelectedIndex].Tabs.SelectionColor = Color.Black;
DataVarList[FileTabs.SelectedIndex].Tabs.SelectionBackColor = Color.WhiteSmoke;
DataVarList[FileTabs.SelectedIndex].Tabs.ReadOnly = true;
//DataVarList[FileTabs.SelectedIndex].Encrypted = true;
DataVarList[FileTabs.SelectedIndex].Tabs.Enabled = false;
Datavar = new DataVariable();
Datavar.Tabs = DataVarList[FileTabs.SelectedIndex].Tabs;
Datavar.Encrypted = true;
Datavar.FileSources = DataVarList[FileTabs.SelectedIndex].FileSources;
DataVarList[FileTabs.SelectedIndex] = Datavar;
Encrpyt_Decrypt_Button.BackColor = Color.LightGray;
UnderlineButton.BackColor = Color.White;
BoldButton.BackColor = Color.White;
ItalicButton.BackColor = Color.White;
BulletPointButton.BackColor = Color.White;
FileTabs.SelectedTab.BackColor = Color.WhiteSmoke;
Datavar = new DataVariable();
}
}
else
{
if (DataVarList[FileTabs.SelectedIndex].Tabs.Text != "")
{
Save_Open__File Save_Open = new Save_Open__File(DataVarList, Source);
DataVarList[FileTabs.SelectedIndex].Tabs.WordWrap = false;
string _string = Save_Open.Decrypt(DataVarList[FileTabs.SelectedIndex].Tabs.Text);
DataVarList[FileTabs.SelectedIndex].Tabs.Rtf = _string;
DataVarList[FileTabs.SelectedIndex].Tabs.ReadOnly = false;
//DataVarList[FileTabs.SelectedIndex].Encrypted = false;
DataVarList[FileTabs.SelectedIndex].Tabs.SelectionStart = DataVarList[FileTabs.SelectedIndex].Tabs.Text.Length;
DataVarList[FileTabs.SelectedIndex].Tabs.Enabled = true;
Datavar = new DataVariable();
Datavar.Tabs = DataVarList[FileTabs.SelectedIndex].Tabs;
Datavar.Encrypted = false;
Datavar.FileSources = DataVarList[FileTabs.SelectedIndex].FileSources;
DataVarList[FileTabs.SelectedIndex] = Datavar;
Encrpyt_Decrypt_Button.BackColor = Color.White;
CheckButtonBackground();
FileTabs.SelectedTab.BackColor = DataVarList[FileTabs.SelectedIndex].Tabs.BackColor;
Datavar = new DataVariable();
}
}
}
}
public void SaveFile(TabControl FileTabs, List <DataVariable> DataVar)
{
string RTBText = "";
string FileName = FileTabs.SelectedTab.Text;
if (FileName.Contains("NewPage"))
{
FileName = "";
Stream myStream;
SaveFileDialog saveFileDialog1 = new SaveFileDialog();
int FileNameL = 0;
saveFileDialog1.Filter = "txt files (*.txt)|*.txt";
saveFileDialog1.FilterIndex = 2;
saveFileDialog1.RestoreDirectory = true;
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
{
if ((myStream = saveFileDialog1.OpenFile()) != null)
{
// Code to write the stream goes here.
string change;
change = saveFileDialog1.FileName;
for (int loop = 0; loop < change.Length; loop++)
{
if (change[loop] == '\\')
{
FileNameL = 0;
}
else
{
FileNameL++;
}
}
for (int loop = change.Length - FileNameL; loop < change.Length; loop++)
{
FileName += change[loop];
}
FileTabs.SelectedTab.Text = FileName;
FileName = change;
myStream.Close();
//DataVar[FileTabs.SelectedIndex].FileSources = change;
DataVariable DatavarTemp = new DataVariable();
DatavarTemp.Tabs = DataVar[FileTabs.SelectedIndex].Tabs;
DatavarTemp.Encrypted = DataVar[FileTabs.SelectedIndex].Encrypted;
DatavarTemp.FileSources = change;
DataVar[FileTabs.SelectedIndex] = DatavarTemp;
}
}
}
if (!DataVar[FileTabs.SelectedIndex].Encrypted)
{
RTBText = Encrypt(DataVar[FileTabs.SelectedIndex].Tabs.Rtf);
}
BinaryRW write = new BinaryRW();
write.writeBytes(Encryptedbytes, DataVar[FileTabs.SelectedIndex].FileSources);
// Debug.WriteLine("Save Passed " + FileName);
}
public static void Clear(DataVariable dataVar)
{
DataVarUIHandler h = GetHandlerForDataVar(dataVar);
if (h != null)
{
h.Clear();
}
}
public void AssignVariableMapping(Mapping mapping, DataVariable var)
{
//Silent return makes it easier to call this when we know sometimes
// var will be unset.
if (var == null)
{
return;
}
variableMappings[(int)mapping] = var;
}
/// <summary> Assign a new dataVar to one of the available handlers, specified by the hander's index.
/// This is useful for loading files and settings from script, then updating things here for UI display.</summary>
/// <param name="newVar"></param>
/// <param name="index">index within the list of all handlers. Is ignored if out of range.</param>
/// <returns>True on success, false if index out of range </returns>
public static bool SetDataVarAtIndex(DataVariable newVar, int index)
{
if (index < 0 || index >= allHandlers.Length)
{
UIManager.I.ShowMessageDialog("SetDataVarAtIndex: out-of-range index passed: " + index + ". Skipping this data variabled.");
return(false);
}
//This will call refreshUI which will take care of headers and label and get it all showing
allHandlers[index].DataVar = newVar;
return(true);
}
/// <summary>
/// Return the handler assigned to the passed dataVariable .
/// </summary>
/// <param name="dataVar"></param>
/// <returns>Null if not found</returns>
public static DataVarUIHandler GetHandlerForDataVar(DataVariable dataVar)
{
foreach (DataVarUIHandler dvh in allHandlers)
{
if (dvh.DataVar == dataVar)
{
return(dvh);
}
}
return(null);
}
public void Tipo_cambio(string inicio)
{
DataVariable datos = a.TipoCambioFechaInicial(inicio);
for (int x = 0; x < datos.TotalItems; x++)
{
txtTipoDesde.Text += "fecha:" + datos.Vars[x].fecha.ToString();
txtTipoDesde.Text += " compra:" + datos.Vars[x].compra.ToString();
txtTipoDesde.Text += " venta:" + datos.Vars[x].venta.ToString() + "\\n";
}
}
private static long DetermineVariableDdi(DataVariable dataVariable)
{
if (dataVariable.IsoUnit == null)
return 6;
var adaptUnit = dataVariable.IsoUnit.ToAdaptUnit();
if (UnitFactory.DimensionToDdi.ContainsKey(adaptUnit.Dimension))
return UnitFactory.DimensionToDdi[adaptUnit.Dimension];
return 6;
}
private static void WriteDataVariable(XmlWriter writer, DataVariable dataVariable)
{
writer.WriteStartElement("PDV");
var variableDdi = DetermineVariableDdi(dataVariable);
writer.WriteAttributeString("A", string.Format(CultureInfo.InvariantCulture, "{0:X4}", variableDdi));
writer.WriteAttributeString("B", dataVariable.IsoUnit.ConvertToIsoUnit(dataVariable.Value).ToString("F0", CultureInfo.InvariantCulture));
writer.WriteXmlAttribute("C", dataVariable.ProductId);
writer.WriteEndElement();
}
private static void WriteDataVariable(XmlWriter writer, DataVariable dataVariable)
{
writer.WriteStartElement("PDV");
var variableDdi = DetermineVariableDdi(dataVariable);
writer.WriteAttributeString("A", string.Format(CultureInfo.InvariantCulture, "{0:X4}", variableDdi));
writer.WriteAttributeString("B", dataVariable.IsoUnit.ConvertToIsoUnit(dataVariable.Value).ToString("F0", CultureInfo.InvariantCulture));
writer.WriteXmlAttribute("C", dataVariable.ProductId);
writer.WriteEndElement();
}
private bool DemoData_LoadSingleDataFile(string filename, out DataVariable dataVar, DataManager.Mapping mapping, int count)
{
string path = Application.streamingAssetsPath + "/sampleData/" + filename;
string errorMsg;
if (!DataManager.I.LoadAddFile(path, true, true, out dataVar, out errorMsg))
{
UIManager.I.ShowMessageDialog("Loading sample data failed.\n" + filename + "\n" + errorMsg);
return(false);
}
DataManager.I.AssignVariableMapping(mapping, dataVar);
DataVarUIHandler.SetDataVarAtIndex(dataVar, count);
return(true);
}
/// <summary>
/// Remove any association with a DataVariable. </summary>
public void Clear()
{
if (_dataVar != null)
{
_dataVar.UIhandler = null;
}
_dataVar = null;
filenameTextMouseHovering = false;
filenameTextMouseEnterTime = float.MaxValue;
filenameTextTooltipShowing = false;
//Empty string indicates not yet specified
filepathSelected = "";
SetFileNeedsLoading(false);
RefreshUIforThisPanel();
}
private static long DetermineVariableDdi(DataVariable dataVariable)
{
if (dataVariable.IsoUnit == null)
{
return(6);
}
var adaptUnit = dataVariable.IsoUnit.ToAdaptUnit();
if (UnitFactory.DimensionToDdi.ContainsKey(adaptUnit.Dimension))
{
return(UnitFactory.DimensionToDdi[adaptUnit.Dimension]);
}
return(6);
}
internal static BroadCastReply ParseAndGet_BroadCastReply_FromXMLDataString(string XMLString)
{
System.IO.StringReader sr = null;
System.Xml.XmlTextReader m_xmlr = null;
BroadCastReply parsedBroadCartReplyfromXMLString = default(BroadCastReply);
try
{
sr = new System.IO.StringReader(XMLString);
m_xmlr = new System.Xml.XmlTextReader(sr);
m_xmlr.WhitespaceHandling = System.Xml.WhitespaceHandling.None;
}
catch (System.Xml.XmlException)
{
string msg;
msg = "Error trying to get XML format from Broad Cast Reply data string [" + XMLString + "]";
}
catch (Exception ex)
{
string msg = "";
msg = "Error trying to parse Broad Cast Reply XML string : " + ex.Message;
throw (new Exception(msg));
}
m_xmlr.Read();
string HeaderIdentifier = m_xmlr.Name;
if (HeaderIdentifier != "BROADCAST_REPLY")
{
throw (new System.Xml.XmlException("Invalid data socket header " + HeaderIdentifier + ". Must be \'BROADCAST_REPLY\'"));
}
else
{
string replyIDName = "";
replyIDName = m_xmlr.GetAttribute("replyIDName");
if (replyIDName == null)
{
throw (new Exception("Invalid XML string for a BroadCastReply, the attribute replyIDName is missing. Can´t parse the string"));
}
string dataXMLString = "";
dataXMLString = m_xmlr.ReadInnerXml();
DataVariable var = default(DataVariable);
var = XMLDataFormatting.RetrieveDataVariableFromXMLString(dataXMLString);
parsedBroadCartReplyfromXMLString = new BroadCastReply(replyIDName, System.Convert.ToString(var.Name), var.Data);
}
return(parsedBroadCartReplyfromXMLString);
}
public void SetValue <T>(BlackboardTargetParameter target, T var)
{
if (EntitiesMap.ContainsKey(target.Target))
{
DataVariable <T> val = GetVariable <T, DataVariable <T> >(target);
if (val)
{
val.Value = var;
}
}
else
{
m_EntitiesMap.Add(target.Target, new ParametersBoard(ParametersMap));
target.Initialize(this);
SetValue <T>(target, var);
}
}
/// <summary> Given a path, try to load/read it, and add to variable list if successful. </summary>
/// <returns></returns>
public bool LoadAddFile(string path, bool hasRowHeaders, bool hasColumnHeaders, out DataVariable dataVar, out string errorMsg)
{
bool success = LoadFile(path, hasRowHeaders, hasColumnHeaders, out dataVar, out errorMsg);
if (success)
{
Debug.Log("Success choosing and loading file.");
variables.Add(dataVar);
//Get filename and set it to label as default
dataVar.Label = Path.GetFileNameWithoutExtension(dataVar.Filepath);
//Update UI
UIManager.I.RefreshUI();
}
else
{
//Error message will have been reported by method above
Debug.Log("Other error while reading file.");
}
return(success);
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.O))
{
string[] paths = StandaloneFileBrowser.OpenFilePanel("Open File", "", "", true);
foreach (string s in paths)
{
Debug.Log(s);
}
if (paths.Length == 0)
{
return;
}
bool success = false;
string errorMsg = "Unknown Error";
//CSVReaderData data = new CSVReaderData();
DataVariable dataVariable = new DataVariable();
CSVReaderData dataObj = (CSVReaderData)dataVariable; // new CSVReaderData();
try
{
success = CSVReader.Read(paths[0], hasColumnsHeader, hasRowHeader, ref dataObj, out errorMsg);
}
catch (Exception e)
{
Debug.Log("Exception caugt: " + e.ToString());
return;
}
if (!success)
{
Debug.Log("Error msg from csv read: ");
Debug.Log(errorMsg);
}
else
{
dataVariable.DumpMetaData();
dataVariable.DumpData();
dataVariable.Clear();
}
}
}
private DataArea CreateDataArea(List <string[]> splitedLines, Dictionary <string, uint> symbolTable, Dictionary <string, DefinedDataVariable> dataVariables)
{
int size = dataVariables.Values.Aggregate(0, (total, current) =>
{
if (current.DataType == DataType.Word)
{
return(total + 4);
}
else
{
return(total + 1);
}
});
int start = splitedLines.Count * 4;
uint currentAddr = (uint)start;
var dataTable = dataVariables.Select(var =>
{
DataVariable newVar = null;
if (var.Value.DataType == DataType.Word)
{
newVar = DataVariable.NewWord(currentAddr, var.Value.StartValue);
symbolTable.Add(var.Key, currentAddr);
currentAddr += 4;
}
else
{
newVar = DataVariable.NewByte(currentAddr, (byte)var.Value.StartValue);
symbolTable.Add(var.Key, currentAddr);
currentAddr += 1;
}
return(newVar);
}).ToList();
return(new DataArea(start, size, dataTable));
}
/// <summary> Restore from a DataStorage object - load data files, applying mappings, set color tables </summary>
/// <param name="data"></param>
/// <returns>True on success </returns>
public bool Restore()
{
bool success = true;
string failedPath = "";
//Clear whatever's currently loaded
DataManager.I.Clear();
foreach (DataVarStorage dvs in dataVars)
{
DataVariable newDataVar = null;
//Load the dataVar's file, and add it to the UI
if (DataManager.I.LoadDataVarFromStorage(dvs, out newDataVar))
{
//We have a list cuz variable might be mapped to more than one visual param
foreach (DataManager.Mapping mapping in dvs.mappings)
{
DataManager.I.AssignVariableMapping(mapping, newDataVar);
}
}
else
{
failedPath = dvs.pathOnly + dvs.filename;
success = false;
}
}
//color tables
UIManager.I.SetColorTableByMappingAndIndex(DataManager.Mapping.SideColor, colorTableIndexSide);
UIManager.I.SetColorTableByMappingAndIndex(DataManager.Mapping.TopColor, colorTableIndexTop);
if (!success)
{
string msg = "One or more variables failed to load. The last one that failed: \n" + failedPath;
UIManager.I.ShowMessageDialog(msg);
}
return(success);
}
private static void AddLiteral(DataArray current, string tmp_literal)
{
int tmp_int;
float tmp_float;
if (int.TryParse(tmp_literal, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out tmp_int))
{
current.AddNode(new DataAtom(tmp_int));
}
else if (float.TryParse(tmp_literal, NumberStyles.Float, NumberFormatInfo.InvariantInfo, out tmp_float))
{
current.AddNode(new DataAtom(tmp_float));
}
else if (tmp_literal[0] == '$')
{
current.AddNode(DataVariable.Var(tmp_literal.Substring(1)));
}
else
{
current.AddNode(DataSymbol.Symbol(tmp_literal));
}
}
/// <summary>
/// For Debugging. load a hardcoded file and assign it to height param and display it
/// </summary>
public bool DebugQuickLoadDefaultAndDraw()
{
DataVariable dataVar;
string path = "C:\\Users\\mgsta\\Documents\\Penn\\IBI\\3dHeatMap\\testData\\simple\\10x10-monotonic-DEcrease-no_headers.csv";
string errorMsg;
bool success = LoadAddFile(path, true, true, out dataVar, out errorMsg);
if (success)
{
Debug.Log("DEBUG: Success choosing and loading file.");
variables.Add(dataVar);
HeightVar = dataVar;
TopColorVar = dataVar;
SideColorVar = dataVar;
Graph.I.Redraw();
}
else
{
Debug.Log("Other error while reading file: \n" + errorMsg);
}
return(success);
}
public void AddPage(string FileName, string _text)
{
TabPage tb = new TabPage(FileName);
tb.BackColor = Color.White;
RichTextBox RTB = new RichTextBox();
RTB.Click += JournalText_Click;
RTB.BorderStyle = BorderStyle.None;
string name = "New Page";
RTB.ScrollBars = RichTextBoxScrollBars.Vertical;
RTB.Multiline = true;
RTB.Dock = DockStyle.Fill;
RTB.WordWrap = false;
tb.Controls.Add(RTB);
RTB.ContextMenuStrip = contextMenuStrip1;
name += NumberPages.ToString();
RTB.Name = name;
FontFamily family = new FontFamily("Times New Roman");
Font new_font = new Font(family, fontsize);
RTB.Font = new_font;
RTB.Rtf = _text;
FileTabs.TabPages.Add(tb);
Datavar = new DataVariable();
Datavar.Tabs = RTB;
Datavar.Encrypted = false;
NumberPages++;
Datavar.FileSources = Source;
DataVarList.Add(Datavar);
FileTabs.SelectTab(NumberPages - 1);
CalcWordCount();
FontText.Text = fontsize.ToString();
//UnRedo.AddPage();
Debug.WriteLine("Added new page " + FileName);
}
/// <summary>
/// Set the UI dropdown choice (Value) according to data variable label.
/// This lets us change the dropdown options/list and set the
/// choice back to what it was pointing at before (or the default if
/// its variable was removed).
/// Note that labels guaranteed to be unique, see DataManager.ForceUniqueLabels()
/// </summary>
/// <param name="dd"></param>
/// <param name="var"></param>
private void SetDropdownValueByVarLabel(DataManager.Mapping mapping, DataVariable var)
{
Dropdown dd = null;
switch (mapping)
{
case DataManager.Mapping.Height: dd = heightLabelDropdown; break;
case DataManager.Mapping.TopColor: dd = topColorLabelDropdown; break;
case DataManager.Mapping.SideColor: dd = sideColorLabelDropdown; break;
}
int index;
if (var == null)
{
index = 0;
}
else
{
//Look at each item in the choice list until we get a match
for (index = 0; index < dd.options.Count; index++)
{
if (dd.options[index].text == var.Label)
{
break;
}
}
}
//If no match, defaults to first item in dropdown
if (index == dd.options.Count)
{
index = 0;
}
SetDropdownValueByMapping(mapping, index);
}
private void Awake()
{
_dataVariable = ScriptableObject.CreateInstance <DataVariable>();
_dataVariable.name = name + "Data";
}
private void AddDataVariable(TreatmentZone treatmentZone, NumericRepresentationValue value, string productId, IsoUnit unit)
{
if (value != null && value.Value != null)
{
var targetValue = value.Value.Value;
// Convert input value to Iso unit
var adaptUnit = unit.ToAdaptUnit();
UnitOfMeasure userUnit = null;
if (adaptUnit != null && value.Value.UnitOfMeasure != null &&
adaptUnit.Dimension == value.Value.UnitOfMeasure.Dimension)
{
userUnit = value.Value.UnitOfMeasure;
targetValue = _unitConverter.Convert(userUnit.ToInternalUom(), adaptUnit.ToInternalUom(), targetValue);
}
var dataVariable = new DataVariable
{
ProductId = productId,
Value = targetValue,
IsoUnit = unit,
UserUnit = userUnit
};
treatmentZone.Variables.Add(dataVariable);
}
}
static DataArray parse_children(System.IO.Stream s, uint numChildren, DataType type = DataType.ARRAY, int version = 1)
{
DataArray ret = type == DataType.MACRO ? new DataMacroDefinition()
: type == DataType.COMMAND ? new DataCommand()
: new DataArray();
while (numChildren-- > 0)
{
DataType t = (DataType)s.ReadInt32LE();
switch (t)
{
case DataType.INT:
ret.AddNode(new DataAtom(s.ReadInt32LE()));
break;
case DataType.FLOAT:
ret.AddNode(new DataAtom(s.ReadFloat()));
break;
case DataType.VARIABLE:
ret.AddNode(DataVariable.Var(s.ReadLengthUTF8()));
break;
case DataType.SYMBOL:
ret.AddNode(DataSymbol.Symbol(s.ReadLengthUTF8()));
break;
case DataType.ARRAY:
case DataType.COMMAND:
case DataType.MACRO:
if (version == 2)
{
s.Position += 4;
uint nC = s.ReadUInt32LE();
ushort unk = s.ReadUInt16LE();
ret.AddNode(parse_children(s, nC, t, version));
}
else if (version == 3)
{
s.Position += 4;
ushort nC = s.ReadUInt16LE();
s.Position += 2;
ret.AddNode(parse_children(s, nC, t, version));
}
else
{
ushort nC = s.ReadUInt16LE(); // numChildren
s.Position += 4; // id
ret.AddNode(parse_children(s, nC, t, version));
}
break;
case DataType.STRING:
ret.AddNode(new DataAtom(s.ReadLengthUTF8()));
break;
case DataType.EMPTY:
s.Position += 4;
break;
case DataType.DEFINE:
var constant = s.ReadLengthUTF8();
numChildren--;
var definition = parse_children(s, 1, DataType.ARRAY, version).Array(0);
ret.AddNode(new DataDefine(constant, definition));
break;
case DataType.IFDEF:
ret.AddNode(new DataIfDef(s.ReadLengthUTF8()));
break;
case DataType.IFNDEF:
ret.AddNode(new DataIfNDef(s.ReadLengthUTF8()));
break;
case DataType.ELSE:
s.Position += 4;
ret.AddNode(new DataElse());
break;
case DataType.ENDIF:
s.Position += 4;
ret.AddNode(new DataEndIf());
break;
case DataType.INCLUDE:
ret.AddNode(new DataInclude(s.ReadLengthUTF8()));
break;
case DataType.MERGE:
ret.AddNode(new DataMerge(s.ReadLengthUTF8()));
break;
case DataType.AUTORUN:
s.Position += 4;
ret.AddNode(new DataAutorun());
break;
case DataType.UNDEF:
ret.AddNode(new DataUndef(s.ReadLengthUTF8()));
break;
default:
throw new Exception("Unhandled DTB DataType " + Enum.GetName(typeof(DataType), t));
}
}
return(ret);
}
