private void nodeTextBoxObjId_DrawText(object sender, Aga.Controls.Tree.NodeControls.DrawTextEventArgs e)
{
DataTreeNode node = e.Node.Tag as DataTreeNode;
ObjectRefTreeNode objRefNode = node as ObjectRefTreeNode;
if (e.Text == "0")
{
e.TextColor = SystemColors.GrayText;
}
else if (objRefNode != null)
{
if (this.IsObjectIdExisting(objRefNode.ObjId))
{
e.TextColor = Color.Blue;
}
else
{
e.TextColor = Color.Red;
}
}
else
{
e.TextColor = Color.Black;
}
}
public object Clone()
{
DataTreeNode result = new DataTreeNode(AddBufferOffset, Length);
result.TotalLength = TotalLength;
return(result);
}
public void OpenFile(string filePath, bool reset = true)
{
if (reset)
{
Reset();
}
// Determine current configuration
ConfigurationList.Instance.DetermineCurrentConfiguration(filePath);
// Create the node
var node = DataNodeFactory.Create(filePath);
// Wrap the node and add it to the tree view
var wrappedNode = new DataTreeNode(node);
mTreeView.Nodes.Add(wrappedNode);
// Restore menu items
mSaveToolStripMenuItem.Enabled = true;
mSaveAsToolStripMenuItem.Enabled = true;
mCloseToolStripMenuItem.Enabled = true;
// Update the title to have the name of node
Text = $"Miku Miku Model - {node.Name}";
// Update the file path for the save method
mCurrentlyOpenFilePath = filePath;
// Expand the node
// TODO: Expanding a large farc archive will lock up the program
wrappedNode.Expand();
}
public Task <int> InvokeAsync(InvocationContext context)
{
var console = context.Console.Out;
var file = context.ParseResult.ValueForOption <string>("file");
object loaded;
try
{
loaded = Proto.ProtoIo.LoadModel(file, new ConsoleLogger(console));
}
catch (Exception ex)
{
console.WriteLine($"Error loading {file}: {ex}");
return(Task.FromResult(1));
}
if (!(loaded is Kit kit))
{
console.WriteLine($"File did not parse as a kit file");
return(Task.FromResult(1));
}
var dataNode = new DataTreeNode(kit.Data, kit.KitRoot);
var json = ConvertToJson(dataNode);
console.WriteLine(json.ToString(Formatting.Indented));
return(Task.FromResult(0));
}
private void treeView_SelectionChanged(object sender, EventArgs e)
{
TreeNodeAdv viewSelNode = this.treeView.SelectedNode;
DataTreeNode selNode = viewSelNode != null ? viewSelNode.Tag as DataTreeNode : null;
this.propertyGrid.SelectObject(selNode != null ? selNode.Data : null);
}
private DataTreeNode <Tuple <Exception, TreeNode> > GetExceptionTreeViewNode(Exception exc)
{
TreeNode treeNode = new TreeNode(exc.GetType().Name);
var childNodes = new List <DataTreeNode <Tuple <Exception, TreeNode> > >();
if (exc.InnerException != null)
{
var childNode = GetExceptionTreeViewNode(exc.InnerException);
childNodes.Add(childNode);
ExceptionsFlatList.Add(childNode);
treeNode.Nodes.Add(childNode.Data.Item2);
}
var aggExc = exc as AggregateException;
if (aggExc?.InnerExceptions != null)
{
foreach (var innerExc in aggExc.InnerExceptions)
{
var childNode = GetExceptionTreeViewNode(innerExc);
childNodes.Add(childNode);
ExceptionsFlatList.Add(childNode);
treeNode.Nodes.Add(childNode.Data.Item2);
}
}
var rootNode = new DataTreeNode <Tuple <Exception, TreeNode> >(
new Tuple <Exception, TreeNode>(
exc, treeNode));
return(rootNode);
}
private void PopulateTreeView(int parentId, DataTreeNode parentNode)
{
String Sequel = "SELECT PARAMETRE_ID,SEVIYE_ADI,UST_SEVIYE_ID, SEVIYE FROM PARAMETRE WHERE UST_SEVIYE_ID=" + parentId + " AND AKTIF=1 ORDER BY SEVIYE_ADI";
DataTable parametreTreeDt = new DataTable();
parametreTreeDt = manager.BasitSorguDT(Sequel, analizConStr);
//TreeNode childNode;
nodMuyum = false;
foreach (DataRow dr in parametreTreeDt.Rows)
{
int parametreId = int.Parse(dr["PARAMETRE_ID"].ToString());
string seviyeAdi = dr["SEVIYE_ADI"].ToString();
int ustSeviyeId = int.Parse(dr["UST_SEVIYE_ID"].ToString());
int seviye = int.Parse(dr["SEVIYE"].ToString());
int isparent = 0;
ParametreSanal parametreSanal = new ParametreSanal(parametreId, seviyeAdi, ustSeviyeId, seviye, isparent);
DataTreeNode node1 = new DataTreeNode(parametreSanal);
if (parentNode == null)
{
treeView1.Nodes.Add(node1);
}
else
{
parentNode.Nodes.Add(node1);
}
PopulateTreeView(Convert.ToInt32(dr["PARAMETRE_ID"].ToString()), node1);
nodMuyum = true;
}
}
private void ShowException(DataTreeNode <Tuple <Exception, TreeNode> > dataNode)
{
var exc = dataNode.Data.Item1;
textBoxExceptionMessage.Text = exc.Message;
textBoxExceptionType.Text = exc.GetType().FullName;
textBoxExceptionStackTrace.Text = exc.StackTrace;
}
private void SetIcons(DataTreeNode node)
{
SetIcon(node);
foreach (var child in node.Nodes)
{
SetIcons((DataTreeNode)child);
}
}
private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
{
DataTreeNode treeViewNode = (DataTreeNode)e.Node; // <--- Node DataTreeNode tipinde
txtPARAMETRE_ID.DataBindings.Clear();
txtSEVIYE_ADI.DataBindings.Clear();
txtUST_SEVIYE_ID.DataBindings.Clear();
txtSEVIYE.DataBindings.Clear();
txtISPARENT.DataBindings.Clear();
txtPARAMETRE_ID.DataBindings.Add("Text", treeViewNode.Data, "PARAMETRE_ID");
txtSEVIYE_ADI.DataBindings.Add("Text", treeViewNode.Data, "SEVIYE_ADI");
txtUST_SEVIYE_ID.DataBindings.Add("Text", treeViewNode.Data, "UST_SEVIYE_ID");
txtSEVIYE.DataBindings.Add("Text", treeViewNode.Data, "SEVIYE");
txtISPARENT.DataBindings.Add("Text", treeViewNode.Data, "ISPARENT");
//MessageBox.Show(((System.Windows.Forms.TreeView)sender).SelectedNode.FullPath.ToString());
//MessageBox.Show(((System.Windows.Forms.TreeView)sender).SelectedNode.Text.ToString());
if (e.Node.Parent == null) // || e.Node.Parent.GetType() == typeof(TreeNode))
{
cmbSeviye.SelectedIndex = int.Parse(txtSEVIYE.Text.ToString());
cmbUstSeviye.SelectedValue = txtPARAMETRE_ID.Text;
}
else
{
nodMuyum = true;
//MessageBox.Show("This is parent node.");
if (e.Node.Parent.GetType() == typeof(DataTreeNode))
{
//if (e.Node.LastNode != null)
{
cmbSeviye.SelectedIndex = int.Parse(txtSEVIYE.Text.ToString());
}
cmbUstSeviye.SelectedValue = txtPARAMETRE_ID.Text;
if (!nodMuyum)
{
cmbSeviye.SelectedIndex = int.Parse(txtSEVIYE.Text.ToString()) - 1;
cmbUstSeviye.SelectedValue = txtUST_SEVIYE_ID.Text;
}
}
else
{
//cmbUstSeviye.SelectedValue = txtUST_SEVIYE_ID.Text;
}
//cmbUstSeviye.SelectedText = e.Node.Parent.Text.ToString();
}
//cmbSeviye.SelectedIndex = int.Parse(txtSEVIYE.Text.ToString());
//cmbUstSeviye.SelectedValue = txtPARAMETRE_ID.Text;
//cmbSeviye.Refresh();
}
private void RetriveChildrenNodes(DataTreeNode node)
{
this.nodeToExpand = node;
object rootId = null;
if (this.nodeToExpand != null)
{
rootId = (this.nodeToExpand.DataSource as TreeViewObjectPickerForm.DataTreeNodeModel).InnerDataRow;
}
this.ObjectPicker.PerformQuery(rootId, string.Empty);
this.InProgress = true;
}
public Project(string path)
{
_projectLocation = path;
_hasMadeChanges = true;
_rootNode = new DataTreeNode("Project", null, false, false);
_rootNode.Nodes.Add(new DataTreeNode("Game Properties", new GameProperties(), false, false));
_rootNode.Nodes.Add(new DataTreeNode("Game Flags", new FlagCollection(), false, false));
_openPanels = new Dictionary <object, DockContent>();
}
private void nodeTextBoxType_DrawText(object sender, Aga.Controls.Tree.NodeControls.DrawTextEventArgs e)
{
DataTreeNode node = e.Node.Tag as DataTreeNode;
ObjectTreeNode objNode = node as ObjectTreeNode;
if (objNode != null && objNode.ResolvedMember == null)
{
e.TextColor = Color.Red;
}
else
{
e.TextColor = Color.Black;
}
}
protected override TreeNode GetTreeNode(Item item, System.Web.UI.Control parent)
{
DataTreeNode dataTreeNode = (DataTreeNode)base.GetTreeNode(item, parent);
foreach (string fieldName in ColumnNames.Keys)
{
if (PredefinedFieldNames.IndexOf(fieldName) != -1)
{
string fieldValue = GetPredefinedFieldValue(item, fieldName);
dataTreeNode.ColumnValues[fieldName] = fieldValue;
}
}
return(dataTreeNode);
}
private static JObject ConvertToJson(DataTreeNode container)
{
var ret = new JObject();
foreach (var child in container.Children)
{
ret.Add(child.SchemaNode.Name, ConvertToJson(child));
}
foreach (var detail in container.Details)
{
ret.Add(detail.Description, ConvertToJson(detail));
}
return(ret);
}
private void resultTreeView_BeforeExpand(object sender, TreeViewCancelEventArgs e)
{
if (this.ObjectPicker.DataTableLoader.Refreshing)
{
e.Cancel = true;
return;
}
DataTreeNode dataTreeNode = e.Node as DataTreeNode;
TreeViewObjectPickerForm.DataTreeNodeModel dataTreeNodeModel = dataTreeNode.DataSource as TreeViewObjectPickerForm.DataTreeNodeModel;
if (!dataTreeNodeModel.IsChildrenReady)
{
e.Cancel = true;
this.RetriveChildrenNodes(dataTreeNode);
}
}
private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
{
DataTreeNode node = (DataTreeNode)e.Node; // <--- Node DataTreeNode tipinde
txtPARAMETRE_ID.DataBindings.Clear();
txtSEVIYE_ADI.DataBindings.Clear();
txtUST_SEVIYE_ID.DataBindings.Clear();
txtSEVIYE.DataBindings.Clear();
txtISPARENT.DataBindings.Clear();
txtPARAMETRE_ID.DataBindings.Add("Text", node.Data, "PARAMETRE_ID");
txtSEVIYE_ADI.DataBindings.Add("Text", node.Data, "SEVIYE_ADI");
txtUST_SEVIYE_ID.DataBindings.Add("Text", node.Data, "UST_SEVIYE_ID");
txtSEVIYE.DataBindings.Add("Text", node.Data, "SEVIYE");
txtISPARENT.DataBindings.Add("Text", node.Data, "ISPARENT");
}
protected override async Task <int> InvokeAsync(InvocationContext context, IStandardStreamWriter console, RolandMidiClient client)
{
using (var device = new DeviceController(client))
{
var schema = device.Schema;
var channel = context.ParseResult.ValueForOption <int>("channel");
var keys = context.ParseResult.ValueForOption <string>("keys");
var targetKit = context.ParseResult.ValueForOption <int>("kit");
if (targetKit < 1 || targetKit + 1 > schema.Kits)
{
console.WriteLine($"Kit {targetKit} is out of range for {schema.Identifier.Name} for this command.");
console.WriteLine("Note that one extra kit is required after the specified one.");
return(1);
}
// Detect the current kit
var currentKit = await device.GetCurrentKitAsync(CancellationToken.None);
// Copy current kit to target kit and target kit + 1
var kit = await device.LoadKitAsync(currentKit, progressHandler : null, CreateCancellationToken());
var dataNode = new DataTreeNode(kit.Data, kit.KitRoot);
await device.SaveDescendants(dataNode, schema.GetKitRoot(targetKit).Container.Address, progressHandler : null, CreateCancellationToken());
await device.SaveDescendants(dataNode, schema.GetKitRoot(targetKit + 1).Container.Address, progressHandler : null, CreateCancellationToken());
await device.SetCurrentKitAsync(targetKit, CancellationToken.None);
var programChangeCommand = (byte)(0xc0 | (channel - 1));
// Now listen for the foot switch...
client.MessageReceived += async(sender, message) =>
{
if (message.Data.Length == 2 && message.Data[0] == programChangeCommand)
{
console.WriteLine("Turning the page...");
SendKeysUtilities.SendWait(keys);
await device.SetCurrentKitAsync(targetKit, CancellationToken.None);
}
};
console.WriteLine("Listening for foot switch");
await Task.Delay(TimeSpan.FromHours(1));
}
return(0);
CancellationToken CreateCancellationToken() => new CancellationTokenSource(10000).Token;
}
public void Duplicate(TreeNode node)
{
if (node == null)
{
return;
}
if (!(node is DataTreeNode dataNode))
{
return;
}
if (!dataNode.IsEditable)
{
return;
}
if (!dataNode.IsMovable)
{
return;
}
// to duplicate easily, we'll just serialize and deserialize the data
var json = JsonConvert.SerializeObject(dataNode.Data, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All,
PreserveReferencesHandling = PreserveReferencesHandling.Objects
});
var copy = JsonConvert.DeserializeObject(json, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All,
PreserveReferencesHandling = PreserveReferencesHandling.Objects
});
var copyNode = new DataTreeNode(dataNode.Text + " - Copy", copy);
node.Parent.Nodes.Add(copyNode);
dataNode.Expand();
Save(false, true);
SetIcon(copyNode);
copyNode.BeginEdit();
}
public void ShowTreeNodesRecursive(DataTreeNode oParentNode, string aranan)
{
//debug
//Console.WriteLine(oParentNode.Text);
//MessageBox.Show(((System.Windows.Forms.TreeView)sender).SelectedNode.Text.ToString());
//MessageBox.Show(treeView1.SelectedNode.FullPath.ToString());
if (oParentNode.FullPath.ToString() == aranan)
{
treeView1.SelectedNode = oParentNode;
treeView1.SelectedNode.BackColor = Color.Blue;
}
// Start recursion on all subnodes.
foreach (DataTreeNode oSubNode in oParentNode.Nodes)
{
ShowTreeNodesRecursive(oSubNode, aranan);
}
}
public void LoadFile(string filePath)
{
if (!File.Exists(filePath))
{
throw new FileNotFoundException("Can't open Resource file. File not found.", filePath);
}
this.ClearData();
this.actionRenameType.Enabled = true;
this.actionSave.Enabled = true;
this.filePath = filePath;
using (FileStream fileStream = File.OpenRead(this.filePath))
{
using (var formatter = Formatter.CreateMeta(fileStream))
{
DataNode dataNode;
try
{
this.treeView.BeginUpdate();
while ((dataNode = formatter.ReadObject <DataNode>()) != null)
{
DataTreeNode data = this.AddData(dataNode);
this.rootData.Add(data);
}
}
catch (EndOfStreamException) {}
catch (Exception e)
{
Log.Editor.WriteError("Can't load file {0} because an error occurred in the process: \n{1}",
this.filePath,
Log.Exception(e));
return;
}
finally
{
foreach (DataTreeNode n in this.rootData)
{
this.dataModel.Nodes.Add(n);
}
this.treeView.EndUpdate();
}
}
}
}
protected DataTreeNode AddData(DataNode data)
{
// Register type data layout nodes
if (data is TypeDataLayoutNode)
{
this.typeDataLayout[(data.Parent as ObjectNode).TypeString] = data as TypeDataLayoutNode;
}
DataTreeNode dataNode = DataTreeNode.Create(data);
foreach (DataNode child in data.SubNodes)
{
DataTreeNode childDataNode = this.AddData(child);
childDataNode.Parent = dataNode;
}
this.UpdateTypeDataLayout(dataNode, false);
return(dataNode);
}
private ModuleData(TreeNode logicalSchemaRoot)
{
PhysicalRoot = logicalSchemaRoot.Container;
if (!(PhysicalRoot is ContainerBase containerBase))
{
throw new ArgumentException("Invalid root for ModuleData");
}
var schema = PhysicalRoot.Schema;
var fieldContainers = containerBase.DescendantsAndSelf().OfType <FieldContainer>().ToList();
// First populate the containers
var fieldMap = new SortedDictionary <FieldContainer, IReadOnlyList <IDataField> >(FieldContainer.AddressComparer);
foreach (var fieldContainer in fieldContainers)
{
fieldMap[fieldContainer] = fieldContainer.Fields.ToReadOnlyList(field => DataFieldBase.CreateDataField(field, schema));
}
fieldsByFieldContainer = fieldMap;
IEnumerable <DataFieldBase> allFields = fieldsByFieldContainer.SelectMany(pair => pair.Value).Cast <DataFieldBase>();
// Now resolve fields
foreach (var pair in fieldsByFieldContainer)
{
foreach (var field in pair.Value.Cast <DataFieldBase>())
{
field.ResolveFields(this, pair.Key);
}
}
// Reset all fields to default values.
foreach (var pair in fieldsByFieldContainer)
{
foreach (var field in pair.Value)
{
field.Reset();
}
}
// Note: must populate this *after* containers.
LogicalRoot = new DataTreeNode(this, logicalSchemaRoot);
}
private void Open(DataTreeNode dataNode)
{
if (dataNode?.Data == null)
{
//dataNode.Toggle();
return;
}
var data = dataNode.Data;
if (_openPanels.ContainsKey(data))
{
_openPanels[data].Show();
return;
}
if (data.GetType() == typeof(Script))
{
OpenEditor <ScriptEditor, Script>(dataNode);
}
}
private ModuleData(TreeNode logicalSchemaRoot)
{
var schema = logicalSchemaRoot.Container.Schema;
var fieldContainers = logicalSchemaRoot.DescendantFieldContainers().ToList();
originalSegmentsByFieldContainer = new Dictionary <FieldContainer, DataSegment>();
// First populate the containers
var fieldMap = new SortedDictionary <FieldContainer, IReadOnlyList <IDataField> >(FieldContainer.AddressComparer);
foreach (var fieldContainer in fieldContainers)
{
fieldMap[fieldContainer] = fieldContainer.Fields.ToReadOnlyList(field => DataFieldBase.CreateDataField(field, schema));
originalSegmentsByFieldContainer[fieldContainer] = new DataSegment(fieldContainer.Address, new byte[fieldContainer.Size]);
}
fieldsByFieldContainer = fieldMap;
IEnumerable <DataFieldBase> allFields = fieldsByFieldContainer.SelectMany(pair => pair.Value).Cast <DataFieldBase>();
// Now resolve fields
foreach (var pair in fieldsByFieldContainer)
{
foreach (var field in pair.Value.Cast <DataFieldBase>())
{
field.ResolveFields(this, pair.Key);
}
}
// Reset all fields to default values.
foreach (var pair in fieldsByFieldContainer)
{
foreach (var field in pair.Value)
{
field.Reset();
}
}
// Note: must populate this *after* containers.
LogicalRoot = new DataTreeNode(this, logicalSchemaRoot);
}
private void treeDataDoldur()
{
treeView1.Nodes.Clear();
String Sequel = "SELECT PARAMETRE_ID,SEVIYE_ADI,UST_SEVIYE_ID, SEVIYE FROM PARAMETRE WHERE UST_SEVIYE_ID=0 AND AKTIF=1 ORDER BY SEVIYE_ADI";
DataTable ParametreDt = new DataTable();
ParametreDt = manager.BasitSorguDT(Sequel, analizConStr);
foreach (DataRow dr in ParametreDt.Rows)
{
int parametreId = int.Parse(dr["PARAMETRE_ID"].ToString());
string seviyeAdi = dr["SEVIYE_ADI"].ToString();
int ustSeviyeId = int.Parse(dr["UST_SEVIYE_ID"].ToString());
int seviye = int.Parse(dr["SEVIYE"].ToString());
int isParent = 1;
ParametreSanal parametreSanal = new ParametreSanal(parametreId, seviyeAdi, ustSeviyeId, seviye, isParent);
DataTreeNode node1 = new DataTreeNode(parametreSanal);
treeView1.Nodes.Add(node1);
PopulateTreeView(Convert.ToInt32(dr["PARAMETRE_ID"].ToString()), node1);
}
treeView1.LineColor = Color.Teal;
treeView1.CollapseAll();
//treeView1.ExpandAll();
}
private void SetIcon(DataTreeNode node, int index)
{
node.ImageIndex = index;
node.StateImageIndex = index;
node.SelectedImageIndex = index;
}
public object Clone ()
{
DataTreeNode result = new DataTreeNode (AddBufferOffset, Length);
result.TotalLength = TotalLength;
return result;
}
public void AssignTree(DockPanel panel, TreeView treeView, TreeView filter, Control bar, Control bar2)
{
_dockPanel = panel;
_bar = bar;
_bar2 = bar2;
MoveBar(-10000, 0);
_dockPanel.ActivePaneChanged += (sender, args) => { Save(false, true); };
treeView.Nodes.Clear();
treeView.LabelEdit = true;
treeView.BeforeLabelEdit += (sender, args) =>
{
var node = args.Node;
if (node == null)
{
return;
}
if (node is DataTreeNode dataNode)
{
if (!dataNode.IsEditable)
{
args.CancelEdit = true;
}
}
};
treeView.AfterLabelEdit += (sender, args) =>
{
if (args.Label == null || args.Label.Trim() == string.Empty)
{
args.CancelEdit = true;
return;
}
var node = args.Node;
if (node == null)
{
return;
}
if (node is DataTreeNode dataNode)
{
if (!dataNode.IsEditable)
{
args.CancelEdit = true;
return;
}
dataNode.Text = args.Label;
if (dataNode.Data != null)
{
if (_openPanels.ContainsKey(dataNode.Data))
{
_openPanels[dataNode.Data].Text = dataNode.Text;
}
}
Save(false, true);
}
};
treeView.DoubleClick += (sender, args) =>
{
var node = treeView.SelectedNode;
if (node == null)
{
return;
}
if (node is DataTreeNode dataNode)
{
Open(dataNode);
}
};
filter.DoubleClick += (sender, args) =>
{
var node = filter.SelectedNode;
if (node == null)
{
return;
}
if (node is DataTreeNode dataNode)
{
Open(dataNode);
}
};
treeView.AllowDrop = true;
treeView.ItemDrag += (sender, args) =>
{
if (((DataTreeNode)args.Item).IsMovable)
{
treeView.DoDragDrop(args.Item, DragDropEffects.Move);
}
};
treeView.DragEnter += (sender, args) => { args.Effect = DragDropEffects.Move; };
treeView.DragOver += (sender, args) =>
{
var target = treeView.PointToClient(new Point(args.X, args.Y));
var targetNode = (DataTreeNode)treeView.GetNodeAt(target);
var draggedNode = (DataTreeNode)args.Data.GetData(typeof(DataTreeNode));
var buffer = 6;
if (targetNode == null)
{
return;
}
var targetNodePosition = targetNode.Bounds;
if (hovered != null && hovered != targetNode)
{
hovered.BackColor = Color.White;
hovered.ForeColor = Color.Black;
}
if (targetNode.Parent == null ||
targetNode.Parent != null && targetNode.Data != null &&
targetNode.Data.GetType() == typeof(GameProperties))
{
MoveBar(-10000, 0);
return;
}
targetNode.BackColor = SystemColors.Highlight;
targetNode.ForeColor = SystemColors.HighlightText;
if (target.Y < targetNodePosition.Top + buffer)
{
// move above
MoveBar(targetNodePosition.Top, targetNodePosition.Left);
}
else if (target.Y > targetNodePosition.Bottom - buffer)
{
// move below
MoveBar(targetNodePosition.Bottom, targetNodePosition.Left);
}
else
{
if (CanDropInto(targetNode, draggedNode))
{
MoveBar(targetNodePosition.Top, targetNodePosition.Left, true, treeView.ItemHeight);
}
else
{
MoveBar(-10000, 0);
}
}
hovered = targetNode;
};
treeView.DragDrop += (sender, args) =>
{
var target = treeView.PointToClient(new Point(args.X, args.Y));
var targetNode = (DataTreeNode)treeView.GetNodeAt(target);
var draggedNode = (DataTreeNode)args.Data.GetData(typeof(DataTreeNode));
if (targetNode == null)
{
return;
}
var targetNodePosition = targetNode.Bounds;
var buffer = 6;
MoveBar(-10000, 0);
if (hovered != null)
{
hovered.BackColor = Color.White;
hovered.ForeColor = Color.Black;
}
if (targetNode != null)
{
targetNode.BackColor = Color.White;
targetNode.ForeColor = Color.Black;
}
if (draggedNode != null)
{
draggedNode.BackColor = Color.White;
draggedNode.ForeColor = Color.Black;
}
if (!(!draggedNode.Equals(targetNode) && targetNode != null))
{
return;
}
if (!draggedNode.IsMovable)
{
return;
}
if (target.Y < targetNodePosition.Top + buffer)
{
// do not allow moving above properties
if (targetNode.Parent != null && targetNode.Data != null &&
targetNode.Data.GetType() == typeof(GameProperties))
{
return;
}
// move above
if (targetNode.Parent != null)
{
draggedNode.Remove();
targetNode.Parent.Nodes.Insert(targetNode.Index, draggedNode);
}
}
else if (target.Y > targetNodePosition.Bottom - buffer)
{
// move below
if (targetNode.Parent != null)
{
draggedNode.Remove();
targetNode.Parent.Nodes.Insert(targetNode.Index + 1, draggedNode);
}
}
else
{
if (!CanDropInto(targetNode, draggedNode))
{
return;
}
draggedNode.Remove();
targetNode.Nodes.Add(draggedNode);
targetNode.Expand();
}
Save(false, true);
};
var imageList = new ImageList();
imageList.Images.Add(Resources.SourceConrolFolder_16x);
imageList.Images.Add(Resources.FolderClosed_16x);
imageList.Images.Add(Resources.FolderOpened_16x);
imageList.Images.Add(Resources.Settings_16x);
imageList.Images.Add(Resources.Script_16x);
treeView.ImageList = imageList;
treeView.AfterExpand += UpdateIcon;
treeView.AfterCollapse += UpdateIcon;
treeView.Nodes.Add(_rootNode);
_rootNode.Expand();
SetIcons(_rootNode);
}
protected override async Task <int> InvokeAsync(InvocationContext context, IStandardStreamWriter console, DeviceController device)
{
var kit = context.ParseResult.ValueForOption <int>("kit");
var triggerRoot = device.Schema.GetTriggerRoot(kit, trigger: 1);
var deviceData = ModuleData.FromLogicalRootNode(triggerRoot);
var modelData = ModuleData.FromLogicalRootNode(triggerRoot);
var defaultValuesSnapshot = modelData.CreateSnapshot();
var deviceDataRoot = new DataTreeNode(deviceData, triggerRoot);
await device.LoadDescendants(deviceDataRoot, targetAddress : null, progressHandler : null, CancellationToken.None);
var originalSnapshot = deviceData.CreateSnapshot();
var instrumentField = device.Schema.GetMainInstrumentField(kit, trigger: 1);
var modelInstrumentField = (InstrumentDataField)modelData.GetDataField(instrumentField);
var instrumentContainers = triggerRoot.DescendantFieldContainers();
var differences = new List <Difference>();
var logger = new ConsoleLogger(console);
try
{
// Reset the device to an empty snapshot
deviceData.LoadSnapshot(defaultValuesSnapshot, logger);
await device.SaveDescendants(deviceDataRoot, targetAddress : null, progressHandler : null, CancellationToken.None);
foreach (var instrument in device.Schema.PresetInstruments)
{
// Make the change on the real module and load the data.
// Assumption: the segment containing the instrument itself (e.g. KitPadInst) doesn't
// have any implicit model changes to worry about.
await device.SetInstrumentAsync(kit, trigger : 1, instrument, CancellationToken.None);
await device.LoadDescendants(deviceDataRoot, targetAddress : null, progressHandler : null, CancellationToken.None);
// Make the change in the model.
modelData.LoadSnapshot(defaultValuesSnapshot, logger);
modelInstrumentField.Instrument = instrument;
// Compare the two.
bool anyDifferences = false;
foreach (var container in instrumentContainers)
{
// We won't compare InstrumentDataField, TempoDataField or StringDataField this way, but that's okay.
var realFields = deviceData.GetDataFields(container).SelectMany(ExpandOverlays).OfType <NumericDataFieldBase>().ToList();
var modelFields = modelData.GetDataFields(container).SelectMany(ExpandOverlays).OfType <NumericDataFieldBase>().ToList();
if (realFields.Count != modelFields.Count)
{
console.WriteLine($"Major failure: for instrument {instrument.Id} ({instrument.Group} / {instrument.Name}), found {realFields.Count} real fields and {modelFields.Count} model fields in container {container.Path}");
return(1);
}
foreach (var pair in realFields.Zip(modelFields))
{
var real = pair.First;
var model = pair.Second;
if (real.SchemaField != model.SchemaField)
{
console.WriteLine($"Major failure: for instrument {instrument.Id} ({instrument.Group} / {instrument.Name}), mismatched schema field for {container.Path}: {real.SchemaField.Name} != {model.SchemaField.Name}");
return(1);
}
var realValue = real.RawValue;
var predictedValue = model.RawValue;
if (realValue != predictedValue)
{
anyDifferences = true;
differences.Add(new Difference(instrument, container, real.SchemaField, realValue, predictedValue));
}
}
}
console.Write(anyDifferences ? "!" : ".");
}
}
finally
{
// Restore the original data
deviceData.LoadSnapshot(originalSnapshot, logger);
await device.SaveDescendants(deviceDataRoot, targetAddress : null, progressHandler : null, CancellationToken.None);
}
console.WriteLine();
foreach (var difference in differences)
{
console.WriteLine(difference.ToString());
}
console.WriteLine($"Total differences: {differences.Count}");
return(0);
IEnumerable <IDataField> ExpandOverlays(IDataField field) =>
field is OverlayDataField odf ? odf.CurrentFieldList.Fields : Enumerable.Repeat(field, 1);
}
private void treeDataDoldur()
{
treeView1.Nodes.Clear();
String Sequel = "";
if (Manager.NodTasi == null)
{
Sequel = "SELECT PARAMETRE_ID,SEVIYE_ADI,UST_SEVIYE_ID, SEVIYE FROM PARAMETRE WHERE UST_SEVIYE_ID=0 AND AKTIF=1 ORDER BY SEVIYE_ADI";
}
else
{
bool arama = true;
string yol = "";
arananYol = "";
string sorgu = "";
DataTable yolSor = new DataTable();
sorgu = "SELECT * FROM PARAMETRE WHERE PARAMETRE_ID=" + Manager.NodTasi.ToString();
yolSor = manager.BasitSorguDT(sorgu, analizConStr);
if (yolSor == null || yolSor.Rows.Count == 0)
{
MessageBox.Show("Yol Değerine Ait Bir Tanım Bulunamadı!");
Manager.NodTasi = null;
this.Dispose();
return;
}
yol = yolSor.Rows[0]["PARAMETRE_ID"].ToString();
arananYol = yolSor.Rows[0]["SEVIYE_ADI"].ToString();
if (yolSor.Rows[0]["UST_SEVIYE_ID"].ToString() != "0")
{
do
{
sorgu = "SELECT * FROM PARAMETRE WHERE PARAMETRE_ID=" + yolSor.Rows[0]["UST_SEVIYE_ID"].ToString();
yolSor = manager.BasitSorguDT(sorgu, analizConStr);
arananYol = yolSor.Rows[0]["SEVIYE_ADI"].ToString() + @"\" + arananYol;
if (yolSor.Rows[0]["UST_SEVIYE_ID"].ToString() == "0")
{
yol = yolSor.Rows[0]["PARAMETRE_ID"].ToString();
arama = false;
}
} while (arama);
}
Sequel = "SELECT PARAMETRE_ID,SEVIYE_ADI,UST_SEVIYE_ID, SEVIYE FROM PARAMETRE WHERE PARAMETRE_ID=" + yol + " AND UST_SEVIYE_ID=0 AND AKTIF=1 ORDER BY SEVIYE_ADI";
}
DataTable dt = new DataTable();
dt = manager.BasitSorguDT(Sequel, analizConStr);
foreach (DataRow dr in dt.Rows)
{
int parametreId = int.Parse(dr["PARAMETRE_ID"].ToString());
string seviyeAdi = dr["SEVIYE_ADI"].ToString();
int ustSeviyeId = int.Parse(dr["UST_SEVIYE_ID"].ToString());
int seviye = int.Parse(dr["SEVIYE"].ToString());
int isParent = 1;
ParametreSanal parametreSanal = new ParametreSanal(parametreId, seviyeAdi, ustSeviyeId, seviye, isParent);
DataTreeNode node1 = new DataTreeNode(parametreSanal);
treeView1.Nodes.Add(node1);
PopulateTreeView(Convert.ToInt32(dr["PARAMETRE_ID"].ToString()), node1);
}
treeView1.LineColor = Color.Teal;
nodeBul(arananYol);
//treeView1.CollapseAll();
//treeView1.ExpandAll();
}
