/// <summary> /// Загрузить классы, реализующие интерфейс /// </summary> public void GetTypes() { var t = typeof(ITool); var assemblyTypes = AppDomain.CurrentDomain.GetAssemblies() .SelectMany(typ => typ.GetTypes()) .Where(x => t.IsAssignableFrom(x)); //на всякий случай избавляемся от интерфейсов List <Type> toolTypes = new List <Type>(); foreach (Type type in assemblyTypes) { if (type.IsInterface || type.IsAbstract) { continue; } else { toolTypes.Add(type); } } foreach (Type type in toolTypes) { ITool plugin = (ITool)Activator.CreateInstance(type); ToolList.Add(plugin); } // Пусть первый инструмент будет выбран по умолчанию! ToolList[0].Select(); SelectedTool = ToolList[0]; }
public JsonResult Insert() { if (Request.Form.Count == 0) { return(Json(new ReturnToolList(), JsonRequestBehavior.AllowGet)); } ToolList tool = Newtonsoft.Json.JsonConvert.DeserializeObject <ToolList>(Request.Form[0]); HttpFileCollectionBase file = Request.Files; if (file.Count > 0) { string[] request = new String[file.Count]; string path = "~/Images/"; for (int i = 0; i < file.Count; i++) { string fileName = (string)(Path.GetFileName(file[i].FileName)).Split('.')[0]; string extension = Path.GetExtension(file[i].FileName); fileName = fileName + DateTime.Now.ToString("yyMMddHHmmss") + extension; request[i] = path + fileName; fileName = Path.Combine(Server.MapPath(path), fileName); file[i].SaveAs(fileName); } tool.ImageUrl = JsonConvert.SerializeObject(request); } return(Json(toolDB.Insert(tool), JsonRequestBehavior.AllowGet)); }
void Update() { Frame frame = m_controller.Frame(); // update the pointer controller ToolList tools = frame.Tools; if (m_pointerController) { if (tools.Count > 0) { Tool tool = tools[0]; // leap motion uses different object for vectors Vector3 positionVector = new Vector3(tool.TipPosition.x, tool.TipPosition.y, tool.TipPosition.z); m_pointerController.ToolMoved(positionVector); } // do something with the tracking data in the frame... GestureList gestures = frame.Gestures(); if (gestures.Count > 0) { foreach (Gesture gesture in gestures) { if (gesture.State == Gesture.GestureState.STATESTOP) { m_pointerController.Gesture(gesture); Debug.Log(gesture.Type + " : " + gesture.Duration); } } } } }
public bool SaveTools() { if (CheckPassTool(PreviouslySelectedIndex)) { // Figure out which tools have been removed and if a directory in the tools folder can be removed. // Check if we can delete any toolDirs based on the tools on the remove list. if (Removelist.Count > 0) { var referencedPaths = ToolList.Where(t => !string.IsNullOrEmpty(t.ToolDirPath)) .Select(t => t.ToolDirPath).ToArray(); foreach (var removeTool in Removelist) { if (!string.IsNullOrEmpty(removeTool.ToolDirPath) && Directory.Exists(removeTool.ToolDirPath) && !referencedPaths.Contains(removeTool.ToolDirPath)) { DirectoryEx.SafeDelete(removeTool.ToolDirPath); } } } Settings.Default.ToolList = Properties.ToolList.CopyTools(ToolList); Unsaved = false; Removelist = new List <ToolDescription>(); return(true); } else { return(false); } }
public void AddDialog(string title, string command, string arguments, string initialDirectory, bool isImmediateOutput, string selectedReport, string argsCollectorDllPath, string argsCollectorType, string toolDirPath, string packageVersion, string packageIdentifier, string packageName) { ToolDescription newTool; if (ToolDescription.IsWebPageCommand(command)) { newTool = new ToolDescription(GetTitle(title), command, arguments, string.Empty, false, selectedReport, argsCollectorDllPath, argsCollectorType, toolDirPath, null, packageVersion, packageIdentifier, packageName); } else { newTool = new ToolDescription(GetTitle(title), command, arguments, initialDirectory, isImmediateOutput, selectedReport, argsCollectorDllPath, argsCollectorType, toolDirPath, null, packageVersion, packageIdentifier, packageName); } ToolList.Add(newTool); RefreshListBox(); PreviouslySelectedIndex = -1; listTools.SelectedIndex = ToolList.Count - 1; btnRemove.Enabled = true; }
/// <summary> /// Create new instance of tool for creating lines /// </summary> /// <returns></returns> public Commands.ICommand CreateLineTool() { _tool = new Tools.LineTool(); _cmd = new Commands.LineCommand((Tools.LineTool)_tool); _lastTool = ToolList.LineTool; return _cmd; }
public DataTable toolListToDT(ToolList toolsList) { DataTable toolListTable = new DataTable(); foreach (productionColumnsNames header in Enum.GetValues(typeof(productionColumnsNames))) { toolListTable.Columns.Add(header.ToString()); } foreach (Tool tool in toolsList.toolList) { DataRow dRow = toolListTable.NewRow(); dRow[productionColumnsNames.ToolID.ToString()] = tool.ToolID; dRow[productionColumnsNames.ToolName.ToString()] = tool.ToolName; dRow[productionColumnsNames.ToolType.ToString()] = tool.ToolType.ToString(); dRow[productionColumnsNames.CurrentStatus.ToString()] = tool.CurrentStatus.ToString(); if (tool.CurrentProductionOrder != null) { dRow[productionColumnsNames.ProductName.ToString()] = tool.CurrentProductionOrder.Product.ProductName; dRow[productionColumnsNames.OrderID.ToString()] = tool.CurrentProductionOrder.OrderID; } dRow[productionColumnsNames.TimeRemaining.ToString()] = tool.ProcessingTimeRemaining.ToString(); toolListTable.Rows.Add(dRow); } return(toolListTable); }
public override void OnFrame(Controller leap) { var frame = leap.Frame(); #if true // 今回のフレームで検出したすべての手、指、ツール HandList hands = frame.Hands; FingerList fingers = frame.Fingers; ToolList tools = frame.Tools; PointableList pointables = frame.Pointables; Console.WriteLine(string.Format("手 : {0} 指 : {1} ツール : {2} ポインタ : {3}", hands.Count, fingers.Count, tools.Count, pointables.Count)); #endif #if false // 手のIDから、同じ手を追跡し続ける if (handId == -1) { handId = frame.Hands[0].Id; } else { Hand hand = frame.Hand(handId); handId = hand.Id; // 手の情報を表示する Console.WriteLine(string.Format("ID : {0} 位置 : {1} 速度 : {2} 法線 : {3} 向き : {4}", hand.Id, hand.PalmPosition, hand.PalmVelocity, hand.PalmNormal, hand.Direction)); } #endif #if false // 一番左、右、手前の手を取得する HandList hands = frame.Hands; Hand leftMost = hands.Leftmost; Hand rightMost = hands.Rightmost; Hand frontMost = hands.Frontmost; Console.WriteLine(string.Format("左 : {0} 右 : {1} 手前 : {2}", leftMost.PalmPosition, rightMost.PalmPosition, frontMost.PalmPosition)); #endif #if false // 手に属している指とツールを取得する foreach (var hand in frame.Hands) { Console.WriteLine(string.Format("ID : {0} ポインタ : {1} 指: {2} ツール : {3}", hand.Id, hand.Pointables.Count, hand.Fingers.Count, hand.Fingers.Count)); } #endif #if false // 指の情報を表示する Finger finger = frame.Fingers[0]; Console.WriteLine(string.Format("ID : {0} 位置 : {1} 速度 : {2} 向き : {3}", finger.Id, finger.TipPosition, finger.TipVelocity, finger.Direction)); #endif }
public ToolSelectForm(Form parent, ToolList list) : base(true, parent, list) { InitializeComponent(); _view_mode = molView.Select; _action_result = DialogResult.Cancel; }
private void FixedUpdate() { currentFrame = leapMotionController.Frame(); gestures = currentFrame.Gestures(); hands = currentFrame.Hands; fingers = currentFrame.Fingers; tools = currentFrame.Tools; }
public ToolInfoStruct(ToolList newId, ToolTypes newType, int newTier, int newDamage, Dictionary <ResourceList, int> newRecipe) { id = newId; type = newType; tier = newTier; damage = newDamage; recipe = newRecipe; }
public ProductionManager(ToolList toolList, ToolTypeClassList ToolTypeList) { ToolsList = toolList; ProductionQueue = new Dictionary <ToolTypeClass, ProductionOrderList>(); foreach (var toolType in ToolTypeList.ToolTypeList) { ProductionQueue.Add(toolType, new ProductionOrderList()); } }
public bool UpdateData(ToolList tools) { try { return true; } catch (Exception) { return false; } }
public static void RunTool(ToolList Tools) { //List<Finger> sortedFingers = Fingers.OrderBy(Finger => Finger.Id).ToList(); List <Tool> sortedTools = Tools.ToList(); //temp if (sortedTools[0].TipPosition.z < Properties.Settings.Default.TouchThreshold) { isTouching[0] = true; } else { isTouching[0] = false; } if (isTouching[0] == true && Holding[0] == false) // pressed { JustPressed[0] = true; Holding[0] = true; } if (isTouching[0] == false && Holding[0] == true) // released { JustReleased[0] = true; Holding[0] = false; } if (JustPressed[0]) { JustPressed[0] = false; TouchDown(0, 1); } if (JustReleased[0]) { JustReleased[0] = false; Release(0, 1); } if (Holding[0] == false) { SetHover(0); } if (!Holding[0]) // temp for game { injector[0].PointerInfo.PtPixelLocation.X = (int)(sortedTools[0].TipPosition.x * Properties.Settings.Default.TouchCursorSpeed) + 1000; injector[0].PointerInfo.PtPixelLocation.Y = -(int)(sortedTools[0].TipPosition.y * Properties.Settings.Default.TouchCursorSpeed) + 2500; // speed 15: add 2500 } //injector.Length bool s = TouchInjector.InjectTouchInput(1, injector); }
// Update is called once per frame void FixedUpdate() { if (controller.IsConnected) { Debug.Log("CONNECTED"); // wait until Controller.isConnected() evaluates to true //... Frame frame = controller.Frame(); HandList hands = frame.Hands; PointableList pointables = frame.Pointables; FingerList fingers = frame.Fingers; ToolList tools = frame.Tools; //Alden wrote: //Gesture gesture = frame.Gestures; //for (int g = 0; g < frame.Gestures().Count; g++) //{ // switch (frame.Gestures()[g].Type) // { // case Gesture.GestureType.TYPE_CIRCLE: // //Handle circle gestures // Debug.Log("CIRCLE"); // break; // case Gesture.GestureType.TYPE_KEY_TAP: // //Handle key tap gestures // Debug.Log("KEY TAP"); // break; // case Gesture.GestureType.TYPE_SCREEN_TAP: // //Handle screen tap gestures // Debug.Log("SCREEN TAP"); // break; // case Gesture.GestureType.TYPE_SWIPE: // //Handle swipe gestures // Debug.Log("SWIPE"); // break; // default: // //Handle unrecognized gestures // Debug.Log("UNRECOGNIZED"); // break; // } //} Debug.Log(checkForSwipe()); } else { Debug.Log("NOT CONNECTED"); } }
public async Task <ToolList> GetToolList(int type) { String json_toollist = await _tool_provider.GetToolListAsync(type); DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(ToolList)); MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(json_toollist)); ToolList target = new ToolList(); target = (ToolList)serializer.ReadObject(stream); return(target); }
private static void CopyOldTools(string outerToolsFolderPath, ILongWaitBroker broker) { //Copy tools to a different folder then Directory.Move if successful. string tempOuterToolsFolderPath = string.Concat(outerToolsFolderPath, @"_installing"); if (Directory.Exists(tempOuterToolsFolderPath)) { DirectoryEx.SafeDelete(tempOuterToolsFolderPath); // Not sure this is necessay, but just to be safe if (Directory.Exists(tempOuterToolsFolderPath)) { throw new Exception(Resources.Program_CopyOldTools_Error_copying_external_tools_from_previous_installation); } } // Must create the tools directory to avoid ending up here again next time Directory.CreateDirectory(tempOuterToolsFolderPath); ToolList toolList = Settings.Default.ToolList; int numTools = toolList.Count; const int endValue = 100; int progressValue = 0; // ReSharper disable once UselessBinaryOperation (in case we decide to start at progress>0 for display purposes) int increment = (endValue - progressValue) / (numTools + 1); foreach (var tool in toolList) { string toolDirPath = tool.ToolDirPath; if (!string.IsNullOrEmpty(toolDirPath) && Directory.Exists(toolDirPath)) { string foldername = Path.GetFileName(toolDirPath); string newDir = Path.Combine(outerToolsFolderPath, foldername); string tempNewDir = Path.Combine(tempOuterToolsFolderPath, foldername); if (!Directory.Exists(tempNewDir)) { DirectoryEx.DirectoryCopy(toolDirPath, tempNewDir, true); } tool.ToolDirPath = newDir; // Update the tool to point to its new directory. tool.ArgsCollectorDllPath = tool.ArgsCollectorDllPath.Replace(toolDirPath, newDir); } if (broker.IsCanceled) { // Don't leave around a corrupted directory DirectoryEx.SafeDelete(tempOuterToolsFolderPath); return; } progressValue += increment; broker.ProgressValue = progressValue; } Directory.Move(tempOuterToolsFolderPath, outerToolsFolderPath); Settings.Default.ToolList = ToolList.CopyTools(toolList); }
void Start() { Controller controller = new Controller(); // wait until Controller.isConnected() evaluates to true //... Frame frame = controller.Frame(); HandList hands = frame.Hands; PointableList pointables = frame.Pointables; FingerList fingers = frame.Fingers; ToolList tools = frame.Tools; }
protected virtual void SelectToolLineAction() { ToolList list = ToolList.GetList(moleQule.Base.EEstado.Active, false); ToolSelectForm form = new ToolSelectForm(this, list); if (form.ShowDialog(this) == DialogResult.OK) { ToolInfo item = form.Selected as ToolInfo; _entity.Lines.NewItem(_entity, item); } }
public bool RemoverTool(string ToolName) { if (ToolsDic != null) { if (ToolsDic.ContainsKey(ToolName)) { ToolsDic.Remove(ToolName); ToolList.Remove(ToolList.Find(p => p.ToolName == ToolName)); return(true); } } return(false); }
public bool InsertTool(int index, ITool tool) { if (ToolsDic != null) { if (!ToolsDic.ContainsKey(tool.ToolName)) { ToolsDic.Add(tool.ToolName, tool); ToolList.Insert(index, tool); return(true); } } return(false); }
public bool AddTool(ITool tool) { if (ToolsDic != null) { if (!ToolsDic.ContainsKey(tool.ToolName)) { ToolsDic.Add(tool.ToolName, tool); ToolList.Add(tool); return(true); } } return(false); }
public void testGetToollistFromToolService() { string output = @"{""toollist"":[{""toolID"":10,""toolLabel"":""this is a label""}]}"; var toolProviderMock = Substitute.For <IToolServiceProvider>(); toolProviderMock.GetToolListAsync(1).Returns(Task.FromResult(output)); ToolService target = new ToolService(toolProviderMock); ToolList list = target.GetToolList(1).Result; toolProviderMock.Received().GetToolListAsync(1); Assert.AreEqual(1, list.toollist.Count, "List Should have 1 object"); Assert.AreEqual("this is a label", list.toollist[0].toolLabel, "Tool label is incorrect"); }
public override void UpdateList() { switch (_current_action) { case molAction.Add: if (_entity == null) { return; } List.AddItem(_entity.GetInfo(false)); if (FilterType == IFilterType.Filter) { ToolList listA = ToolList.GetList(_filter_results); listA.AddItem(_entity.GetInfo(false)); _filter_results = listA.GetSortedList(); } break; case molAction.Edit: case molAction.Lock: case molAction.Unlock: if (_entity == null) { return; } ActiveItem.CopyFrom(_entity); break; case molAction.Delete: if (ActiveItem == null) { return; } List.RemoveItem(ActiveOID); if (FilterType == IFilterType.Filter) { ToolList listD = ToolList.GetList(_filter_results); listD.RemoveItem(ActiveOID); _filter_results = listD.GetSortedList(); } break; } RefreshSources(); if (_entity != null) { Select(_entity.Oid); } _entity = null; }
/// <summary> /// Remove the currently selected value. /// </summary> public void Remove() { int spot = listTools.SelectedIndex; if (spot >= Settings.Default.ToolList.Count && !Unsaved) { //Removing a newly added tool } else { Unsaved = true; } Removelist.Add(ToolList[spot]); ToolList.RemoveAt(spot); RefreshListBox(); if (ToolList.Count == 0) { textTitle.Text = string.Empty; textCommand.Text = string.Empty; textArguments.Text = string.Empty; textInitialDirectory.Text = string.Empty; btnRemove.Enabled = false; PreviouslySelectedIndex = -1; cbOutputImmediateWindow.CheckState = CheckState.Unchecked; comboReport.SelectedItem = string.Empty; } // If the removed Index was the last in the list, the selected index is the new last element. else if (spot == ToolList.Count) { // If the removed Index was the last in the list, the selected index is the new last element. listTools.SelectedIndex = spot - 1; } else { listTools.SelectedIndex = spot; //In this case the selected index doesn't actually change so the textBoxes still need to be updated. ToolDescription highlighted = ToolList[listTools.SelectedIndex]; textTitle.Text = highlighted.Title; textCommand.Text = highlighted.Command; textArguments.Text = highlighted.Arguments; textInitialDirectory.Text = highlighted.InitialDirectory; cbOutputImmediateWindow.CheckState = highlighted.OutputToImmediateWindow ? CheckState.Checked : CheckState.Unchecked; comboReport.SelectedItem = ComboContainsTitle(highlighted.ReportTitle) ? highlighted.ReportTitle : string.Empty; } }
public ToolMngForm(bool isModal, Form parent, ToolList list) : base(isModal, parent, list) { InitializeComponent(); SetView(molView.Normal); // Parche para poder abrir el formulario en modo diseño y no perder la configuracion de columnas DatosLocal_BS = Datos; Tabla.DataSource = DatosLocal_BS; SetMainDataGridView(Tabla); Datos.DataSource = ToolList.NewList().GetSortedList(); SortProperty = OName.DataPropertyName; }
public void getTypesCommandReturnsToolListCorrectly() { string output = @"{""toollist"":[{""toolID"":10,""toolLabel"":""this is a label""}]}"; var toolProviderMock = Substitute.For <IToolServiceProvider>(); toolProviderMock.GetToolListAsync(1).Returns(Task.FromResult(output)); ToolService toolservice = new ToolService(toolProviderMock); ToolList toollist = new ToolList(); ToolListViewModel target = new ToolListViewModel(toollist, toolservice); target.GetToolList.Execute(1); Assert.AreEqual(1, target.ToolList.toollist.Count, "Toollist should have 1 element"); Assert.AreEqual(10, target.ToolList.toollist[0].toolID, "ToolID should be 10"); }
private void types_Click(object sender, RoutedEventArgs e) { if (cts != null) { cts.Cancel(); } // In this section, the root of the JSON is an object, which // we then need to map to or store in an instance of a // class we have created. String url = "http://pmb.neongrit.net/aj/selectJSON.php?type=1"; WebRequest request = WebRequest.Create(url); WebResponse ws = request.GetResponse(); ToolList myTools = JsonConvert.DeserializeObject <ToolList>(new StreamReader(ws.GetResponseStream()).ReadToEnd()); tbOutput.Text = String.Format("ID {0} is a {1}", myTools.toollist.First().toolID, myTools.toollist.First().toolLabel); }
protected override void OnStartup(StartupEventArgs e) { base.OnStartup(e); ToolListView view = new ToolListView(); ToolList toolList = new ToolList(); HttpClient httpClient = new HttpClient(); ToolServiceProvider serviceProvider = new ToolServiceProvider(httpClient); ToolService toolService = new ToolService(serviceProvider); ToolListViewModel viewModel = new ToolListViewModel(toolList, toolService); view.DataContext = viewModel; view.Show(); }
/// <summary> /// Asserts that updates are available or not for the sample tool and nested tool, from a given toollist. /// </summary> private static void AssertUpdateAvailability(ToolList toolList, bool sampleToolUpdateAvailable, bool nestedToolUpdateAvailable) { var sampleTool = Settings.Default.ToolList.First(description => description.PackageIdentifier.Equals(SAMPLE_TOOL.PackageIdentifier)); var nestedTools = Settings.Default.ToolList.Where(description => description.PackageIdentifier.Equals(NESTED_TOOL_A.PackageIdentifier)); Assert.IsNotNull(sampleTool); Assert.IsNotNull(nestedTools); Assert.AreEqual(sampleToolUpdateAvailable, sampleTool.UpdateAvailable); foreach (var nestedTool in nestedTools) { Assert.AreEqual(nestedToolUpdateAvailable, nestedTool.UpdateAvailable); } }
/** * Updates tools based on tracking data in the specified Leap ToolList object. * Active ToolModel instances are updated if the tool they represent is still * present in the Leap ToolList; otherwise, the ToolModel is removed. If new * Leap Tool objects are present in the Leap ToolList, new ToolModels are * created and added to the HandController tool list. * @param all_tools The dictionary containing the ToolModels to update. * @param leap_tools The list of tools from the a Leap Frame instance. * @param model The ToolModel instance to use for new tools. */ protected void UpdateToolModels(Dictionary <int, ToolModel> all_tools, ToolList leap_tools, ToolModel model) { List <int> ids_to_check = new List <int>(all_tools.Keys); // Go through all the active tools and update them. int num_tools = leap_tools.Count; for (int h = 0; h < num_tools; ++h) { Tool leap_tool = leap_tools[h]; // Only create or update if the tool is enabled. if (model) { ids_to_check.Remove(leap_tool.Id); // Create the tool and initialized it if it doesn't exist yet. if (!all_tools.ContainsKey(leap_tool.Id)) { ToolModel new_tool = CreateTool(model); new_tool.SetController(this); new_tool.SetLeapTool(leap_tool); new_tool.InitTool(); all_tools[leap_tool.Id] = new_tool; } // Make sure we update the Leap Tool reference. ToolModel tool_model = all_tools[leap_tool.Id]; tool_model.SetLeapTool(leap_tool); tool_model.MirrorZAxis(mirrorZAxis); // Set scaling. tool_model.transform.localScale = transform.lossyScale; tool_model.UpdateTool(); } } // Destroy all tools with defunct IDs. for (int i = 0; i < ids_to_check.Count; ++i) { Destroy(all_tools[ids_to_check[i]].gameObject); all_tools.Remove(ids_to_check[i]); } }
private void ComboBoxChanged(object sender, EventArgs e) { // Reload datagrid with applied filters var toolData = new ToolList(); LoadDataGrid(toolData.Filter(machineComboBox.Text, typeComboBox.Text, functionComboBox.Text)); //reload comboboxes InitializeComboBox(); //Check if combobox empty CheckComboBoxEmpty(functionComboBox); CheckComboBoxEmpty(typeComboBox); //Clear searchbox SearchBox.Text = "Search Tool..."; }
public void verifyNotificationOfToolListChangeOccurs() { string output = @"{""toollist"":[{""toolID"":10,""toolLabel"":""this is a label""}]}"; var toolProviderMock = Substitute.For <IToolServiceProvider>(); toolProviderMock.GetToolListAsync(1).Returns(Task.FromResult(output)); ToolService toolservice = new ToolService(toolProviderMock); ToolList toollist = new ToolList(); ToolListViewModel target = new ToolListViewModel(toollist, toolservice); bool eventWasRaised = false; target.PropertyChanged += (sender, e) => eventWasRaised = e.PropertyName == "ToolList"; target.GetToolList.Execute(1); Assert.IsTrue(eventWasRaised, "Event for toollist change should have been raised"); }
public void TestUpgradedReportSpecList() { var toolList = new ToolList(); toolList.AddDefaults(); var cleanPersistedViews = new PersistedViews(null, null, toolList); for (int oldRevision = 0; oldRevision < 2; oldRevision++) { var oldReportSpecList = new ReportSpecList {RevisionIndex = oldRevision}; oldReportSpecList.AddRange(oldReportSpecList.GetDefaults(oldRevision)); var upgradedPersistedViews = new PersistedViews(oldReportSpecList, null, toolList); foreach (var group in new[] {PersistedViews.MainGroup, PersistedViews.ExternalToolsGroup}) { var cleanViews = cleanPersistedViews.GetViewSpecList(group.Id).ViewSpecs.ToArray(); var upgragedViews = upgradedPersistedViews.GetViewSpecList(group.Id).ViewSpecs.ToArray(); CollectionAssert.AreEquivalent(cleanViews, upgragedViews, "Upgraded from rev {0} in group {1}", oldRevision, group); } } }
/** * Updates tools based on tracking data in the specified Leap ToolList object. * Active ToolModel instances are updated if the tool they represent is still * present in the Leap ToolList; otherwise, the ToolModel is removed. If new * Leap Tool objects are present in the Leap ToolList, new ToolModels are * created and added to the HandController tool list. * @param all_tools The dictionary containing the ToolModels to update. * @param leap_tools The list of tools from the a Leap Frame instance. * @param model The ToolModel instance to use for new tools. */ protected void UpdateToolModels(Dictionary<int, ToolModel> all_tools, ToolList leap_tools, ToolModel model) { List<int> ids_to_check = new List<int>(all_tools.Keys); // Go through all the active tools and update them. int num_tools = leap_tools.Count; for (int h = 0; h < num_tools; ++h) { Tool leap_tool = leap_tools[h]; // Only create or update if the tool is enabled. if (model) { ids_to_check.Remove(leap_tool.Id); // Create the tool and initialized it if it doesn't exist yet. if (!all_tools.ContainsKey(leap_tool.Id)) { ToolModel new_tool = CreateTool(model); new_tool.SetController(this); new_tool.SetLeapTool(leap_tool); new_tool.InitTool(); all_tools[leap_tool.Id] = new_tool; } // Make sure we update the Leap Tool reference. ToolModel tool_model = all_tools[leap_tool.Id]; tool_model.SetLeapTool(leap_tool); tool_model.MirrorZAxis(mirrorZAxis); // Set scaling. tool_model.transform.localScale = Vector3.one; tool_model.UpdateTool(); } } // Destroy all tools with defunct IDs. for (int i = 0; i < ids_to_check.Count; ++i) { Destroy(all_tools[ids_to_check[i]].gameObject); all_tools.Remove(ids_to_check[i]); } }
/// <summary> /// Construct a new PersistedViews, migrating over the values from the old ViewSpecList /// and ReportSpecList properties. Views that are in use by an external tool get put in /// the External Tools group, and views that are /// </summary> public PersistedViews(ReportSpecList reportSpecList, ViewSpecList viewSpecList, ToolList toolList) { var viewItems = new List<ViewSpec>(); if (null != viewSpecList) { viewItems.AddRange(viewSpecList.ViewSpecs); } if (null != reportSpecList) { RevisionIndex = reportSpecList.RevisionIndex + 1; foreach (var newView in ReportSharing.ConvertAll(reportSpecList.Select(reportSpec => new ReportOrViewSpec(reportSpec)), new SrmDocument(SrmSettingsList.GetDefault()))) { if (viewItems.Any(viewSpec => viewSpec.Name == newView.Name)) { continue; } viewItems.Add(newView); } } var viewSpecLists = new Dictionary<ViewGroup, Dictionary<string, ViewSpec>>(); foreach (var viewItem in viewItems) { ViewGroup group; if (toolList.Any(tool => tool.ReportTitle == viewItem.Name)) { group = ExternalToolsGroup; } else { group = MainGroup; } Dictionary<string, ViewSpec> list; if (!viewSpecLists.TryGetValue(group, out list)) { list = new Dictionary<string, ViewSpec>(); viewSpecLists.Add(group, list); } if (!list.ContainsKey(viewItem.Name)) { list.Add(viewItem.Name, viewItem); } else { for (int i = 1;; i++) { string name = viewItem.Name + i; if (!list.ContainsKey(name)) { list.Add(name, viewItem.SetName(name)); break; } } } } foreach (var entry in viewSpecLists) { SetViewSpecList(entry.Key.Id, new ViewSpecList(entry.Value.Values)); } AddDefaults(); }
/// <summary> /// Asserts that updates are available or not for the sample tool and nested tool, from a given toollist. /// </summary> private static void AssertUpdateAvailability(ToolList toolList, bool sampleToolUpdateAvailable, bool nestedToolUpdateAvailable) { var sampleTool = Settings.Default.ToolList.First(description => description.PackageIdentifier.Equals(SAMPLE_TOOL.PackageIdentifier)); var nestedTools = Settings.Default.ToolList.Where(description => description.PackageIdentifier.Equals(NESTED_TOOL_A.PackageIdentifier)); Assert.IsNotNull(sampleTool); Assert.IsNotNull(nestedTools); Assert.AreEqual(sampleToolUpdateAvailable, sampleTool.UpdateAvailable); foreach (var nestedTool in nestedTools) { Assert.AreEqual(nestedToolUpdateAvailable, nestedTool.UpdateAvailable); } }
public ToolBuilder() { _tool = new Tools.LineTool(); _cmd = new Commands.LineCommand((Tools.LineTool)_tool); _lastTool = ToolList.LineTool; }