/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { object mdSliderObject = null; var newPoint = new Point3d(); if (!DA.GetData("UI MD Slider", ref mdSliderObject)) { return; } var hasValue = DA.GetData("Point", ref newPoint); if (newPoint.X > 1.0 || newPoint.Y > 1.0 || newPoint.X < 0 || newPoint.Y < 0) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Point is out of bounds"); } var mdSlider = HUI_Util.GetUIElement <MDSliderElement>(mdSliderObject); if (mdSlider != null && hasValue) { mdSlider.SliderPoint = newPoint; } }
// int sliderIndex = 0; /// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { object SliderObject = null; Interval range = Interval.Unset; double newValue = double.NaN; if (!DA.GetData("UI Slider", ref SliderObject)) { return; } var hasRange = DA.GetData("Range", ref range); var hasValue = DA.GetData("Value", ref newValue); DockPanel dp = HUI_Util.GetUIElement <DockPanel>(SliderObject); var slider = dp.Children.OfType <Grid>().First().Children.OfType <Slider>().First(); if (hasRange) { slider.Minimum = range.Min; slider.Maximum = range.Max; } if (hasValue) { slider.Value = newValue; } }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { List <UIElement_Goo> elementsToAdd = new List <UIElement_Goo>(); bool horiz = true; if (!DA.GetDataList <UIElement_Goo>("UI Elements", elementsToAdd)) { return; } DA.GetData <bool>("Horizontal", ref horiz); //initialize the WrapPanel panel container WrapPanel sp = new WrapPanel(); sp.Name = "GH_WrapPanel"; sp.Orientation = horiz ? Orientation.Horizontal : Orientation.Vertical; foreach (UIElement_Goo u in elementsToAdd) { //Make sure it's not in some other container or window HUI_Util.removeParent(u.element); sp.Children.Add(u.element); } //pass out the WrapPanel panel DA.SetData("WrapPanel", new UIElement_Goo(sp, "WrapPanel", InstanceGuid, DA.Iteration)); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { object CheckBoxObject = null; bool isSelected = false; string newLabelContents = ""; bool SetLabel = DA.GetData <string>("New Check Box Label", ref newLabelContents); if (!DA.GetData <object>("Check Box to modify", ref CheckBoxObject)) { return; } bool SetChecked = DA.GetData <bool>("New Value", ref isSelected); // Since HUI textboxes are actually stackpanels with textboxes inside (since they may or may not also contain a button) // we have to grab the stackpanel first and then find the textbox inside it. //Panel sp = HUI_Util.GetUIElement<Panel>(TextBlockObject); //TextBox tb = HUI_Util.findTextBox(sp); CheckBox cb = HUI_Util.GetUIElement <CheckBox>(CheckBoxObject); // if (cb != null) { //set the text of the textbox. if (SetLabel) { cb.Content = newLabelContents; } if (SetChecked) { cb.IsChecked = isSelected; } } }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { bool show = true; bool collapse = true; object elem = null; bool disable = false; if (!DA.GetData <bool>("Show", ref show)) { return; } DA.GetData <bool>("Collapse", ref collapse); bool hasDisable = DA.GetData <bool>("Disable", ref disable); if (!DA.GetData <object>("Element to Hide/Show", ref elem)) { return; } //Get the "FrameworkElement" (basic UI element) from an object FrameworkElement f = HUI_Util.GetUIElement <FrameworkElement>(elem); if (hasDisable) { f.IsEnabled = !disable; } f.Visibility = show ? Visibility.Visible : (collapse ? Visibility.Collapsed : Visibility.Hidden); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { System.Drawing.Color defaultCol = System.Drawing.Color.Transparent; List <System.Drawing.Color> availableCols = new List <System.Drawing.Color>(); //initialize the picker with default settings ColorPicker picker = new ColorPicker(); //If the user specified a default color, set the picker's selected color. if (DA.GetData <System.Drawing.Color>("Default Color", ref defaultCol)) { picker.SelectedColor = HUI_Util.ToMediaColor(defaultCol); } //if the user specified a list of allowed colors, replace the picker's availableColors list and disable standard colors. if (DA.GetDataList <System.Drawing.Color>("Available Colors", availableCols)) { ObservableCollection <ColorItem> cols = new ObservableCollection <ColorItem>(); foreach (System.Drawing.Color cw in availableCols) { Color c = HUI_Util.ToMediaColor(cw); cols.Add(new ColorItem(c, String.Format("{0},{1},{2}", c.R, c.B, c.G))); picker.AvailableColors = cols; picker.ShowStandardColors = false; } } DA.SetData("Color Picker", new UIElement_Goo(picker, "Color Picker", InstanceGuid, DA.Iteration)); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { object ButtonObject = null; string newButtonName = ""; string newButtonImage = ""; if (!DA.GetData <object>("Button to modify", ref ButtonObject)) { return; } bool hasText = DA.GetData <string>("Button Name", ref newButtonName); bool hasIcon = DA.GetData <string>("Image Path", ref newButtonImage); Button btn = HUI_Util.GetUIElement <Button>(ButtonObject); if (btn == null) { return; } if (!hasText && !hasIcon) { return; } //Initialize the button //Button btn = new Button(); //make button not focusable //btn.Focusable = false; UpdateButton(newButtonName, newButtonImage, hasText, hasIcon, btn); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { object tabContainer = null; List <string> tabNames = new List <string>(); List <bool> hideTabs = new List <bool>(); if (!DA.GetData("Tabbed View", ref tabContainer)) { return; } bool hasNames = DA.GetDataList("Tab Names", tabNames); bool hasHideTabs = DA.GetDataList("Show Tabs", hideTabs); TabControl tabControl = HUI_Util.GetUIElement <TabControl>(tabContainer); for (int i = 0; i < tabControl.Items.Count; i++) { var item = tabControl.Items[i]; var tabItem = item as TabItem; if (hasNames && tabNames.Count > i) { tabItem.Header = tabNames[i]; } if (hasHideTabs && hideTabs.Count > i) { tabItem.Visibility = hideTabs[i] ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed; if (!hideTabs[i] && tabControl.SelectedIndex == i) { tabControl.SelectedIndex = (i + 1) % tabControl.Items.Count; } } } }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { bool open = true; string header = ""; DA.GetData <bool>("Open", ref open); DA.GetData <string>("Header", ref header); List <UIElement_Goo> elementsToAdd = new List <UIElement_Goo>(); if (!DA.GetDataList <UIElement_Goo>("UI Elements", elementsToAdd)) { return; } Expander e = new Expander(); StackPanel sp = new StackPanel(); sp.Name = "GH_Stack"; foreach (UIElement_Goo u in elementsToAdd) { //Make sure it's not in some other container or window HUI_Util.removeParent(u.element); sp.Children.Add(u.element); } e.IsExpanded = open; e.Content = sp; e.Header = header; DA.SetData("Expander", new UIElement_Goo(e, "Expander", InstanceGuid, DA.Iteration)); }
/// <summary> /// Write all required data for deserialization to an IO archive. /// </summary> /// <param name="writer">Object to write with.</param> /// <returns> /// True on success, false on failure. /// </returns> public override bool Write(GH_IWriter writer) { //serialize the states GH_IWriter stateSetChunk = writer.CreateChunk("stateSetChunk"); stateSetChunk.SetInt32("StateCount", savedStates.states.Count); int i = 0; //the state //for each state in saved states foreach (KeyValuePair <string, State> statePair in savedStates.states) { string stateName = statePair.Key; GH_IWriter StateChunk = stateSetChunk.CreateChunk("State", i); StateChunk.SetString("stateName", stateName); State state = statePair.Value; StateChunk.SetInt32("itemCount", state.stateDict.Count); int j = 0; //Custom serialization logic //for each element in the state foreach (KeyValuePair <UIElement_Goo, object> stateItem in state.stateDict) { //get element and value UIElement_Goo element = stateItem.Key; object value = stateItem.Value; GH_IWriter stateItemChunk = StateChunk.CreateChunk("stateItem", j); //this info is used to retrieve the dynamic UI element on reserialization, by grabbing the component with matching instance guid //and getting the output item at the matching index. stateItemChunk.SetString("ElementID", element.instanceGuid.ToString()); stateItemChunk.SetInt32("ElementIndex", element.index); string stringValue = value.ToString(); string typeString = value.GetType().ToString(); //special case for lists of bool - all other element "states" are single items. This only applies to a checklist object. if (value is List <bool> ) { typeString = "LIST OF BOOL"; stringValue = HUI_Util.stringFromBools((List <bool>)value); } if (value is List <string> ) { typeString = "LIST OF STRING"; stringValue = HUI_Util.stringFromStrings((List <string>)value); } //store the value and a hint as to its type stateItemChunk.SetString("ElementValue", stringValue); stateItemChunk.SetString("ElementValueType", typeString); j++; //counting up elements in state } i++; //counting up states } return(base.Write(writer)); }
/// <summary> /// Gets the value of a serialized object from a string and the saved type. /// </summary> /// <param name="value">The string value.</param> /// <param name="valueType">Data type of the value.</param> /// <returns></returns> object getValue(string value, string valueType) { switch (valueType) { case "System.Double": double dbl; Double.TryParse(value, out dbl); return(dbl); case "System.Boolean": bool bl; Boolean.TryParse(value, out bl); return(bl); case "LIST OF BOOL": return(HUI_Util.boolsFromString(value)); case "LIST OF STRING": return(HUI_Util.stringsFromString(value)); case "System.Drawing.Color": string[] res = value.Split("=,]".ToCharArray()); int A, R, G, B; Int32.TryParse(res[1], out A); Int32.TryParse(res[3], out R); Int32.TryParse(res[5], out G); Int32.TryParse(res[7], out B); return(System.Drawing.Color.FromArgb(A, R, G, B)); default: return(value); } }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { bool restore = false; string setName = ""; StateSet_Goo states = null; if (!DA.GetData <StateSet_Goo>("Saved States", ref states)) { return; } if (!DA.GetData <string>("State Name to restore", ref setName)) { return; } DA.GetData <bool>("Restore", ref restore); //if there's an output param, pass out the value of restore. if (Params.Output.Count > 0) { DA.SetData(0, restore); } if (!restore) { return; } //retrieve the appropriate state from the state set dictionary State stateToRestore = states.states[setName]; //restore state foreach (KeyValuePair <UIElement_Goo, object> elementState in stateToRestore.stateDict) { UIElement element = elementState.Key.element; //if it has a parent, it's a real element that exists - if the parent is null we are in a new document session and the original element //may not really exist any longer. var parent = System.Windows.Media.VisualTreeHelper.GetParent(element); //This is the situation when opening a definition fresh - we have to retrtieve the element based on the saved state's //component instance guid and output data index. Because there's no way to serialize a UIElement we have to retrieve it // from the component actively creating it (or more precisely a new but identical instance of it) if (parent == null) { Guid id = elementState.Key.instanceGuid; int index = elementState.Key.index; UIElement_Goo newGoo = SaveElementState_Component.getElementGoo(this.OnPingDocument(), id, index); element = newGoo.element; } //Once we've got the element, try to set its value. HUI_Util.TrySetElementValue(HUI_Util.extractBaseElement(element), elementState.Value); } }
protected override void SolveInstance(IGH_DataAccess DA) { object elem = null; string propName = ""; object val = null; if (!DA.GetData("UI Element", ref elem)) { return; } if (!DA.GetData("Property Name", ref propName)) { return; } if (!DA.GetData("Value to set", ref val)) { return; } object unwrappedElem = HUI_Util.GetUIElement <UIElement>(elem); if (val is GH_ObjectWrapper) { val = (val as GH_ObjectWrapper).Value; } else if (val is IGH_Goo) { try { val = val.GetType().GetProperty("Value").GetValue(val); } catch { } } var type = unwrappedElem.GetType(); var prop = type.GetProperty(propName); if (prop == null) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, $"Object type {type} does not contain a property called {propName}"); return; } try { prop.SetValue(unwrappedElem, val); } catch (Exception e) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, $"Something went wrong setting the property:\n{e.Message}"); } }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { List <Curve> shapeCrvs = new List <Curve>(); System.Drawing.Color fillCol = System.Drawing.Color.Transparent; double strokeWeight = 0.0; System.Drawing.Color strokeCol = System.Drawing.Color.Transparent; double scale = 1.0; int width = 0; int height = 0; if (!DA.GetDataList <Curve>("Shape", shapeCrvs)) { return; } //initialize path object Path path = new Path(); DA.GetData <double>("Scale", ref scale); //set path data to geometry from curve list path.Data = pathGeomFromCrvs(shapeCrvs, scale, false); if (DA.GetData <System.Drawing.Color>("Fill Color", ref fillCol)) { path.Fill = new SolidColorBrush(HUI_Util.ToMediaColor(fillCol)); } if (DA.GetData <double>("Stroke Weight", ref strokeWeight)) { path.StrokeThickness = strokeWeight; } if (DA.GetData <System.Drawing.Color>("Stroke Color", ref strokeCol)) { path.Stroke = new SolidColorBrush(HUI_Util.ToMediaColor(strokeCol)); } //initialize a grid to contain the shapes Grid G = new Grid(); if (DA.GetData <int>("Width", ref width)) { G.Width = width; } if (DA.GetData <int>("Height", ref height)) { G.Height = height; } G.Children.Add(path); //pass out the grid containing the shape DA.SetData("Shape", new UIElement_Goo(G, "Shape", InstanceGuid, DA.Iteration)); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { object ChartObject = null; List <double> listContents = new List <double>(); List <string> names = new List <string>(); bool Legend = true; bool Title = true; List <System.Drawing.Color> Col = new List <System.Drawing.Color>(); System.Drawing.Color fgCol = System.Drawing.Color.Transparent; //Get the Chart object and assign it if (!DA.GetData <object>("Chart to modify", ref ChartObject)) { return; } var ChartElem = HUI_Util.GetUIElement <ChartBase>(ChartObject); bool hasLegend = DA.GetData <bool>("Legend", ref Legend); bool hasTitle = DA.GetData <bool>("Title", ref Title); bool hasColors = DA.GetDataList <System.Drawing.Color>("Colors", Col); if (hasColors) { ResourceDictionaryCollection Palette = new ResourceDictionaryCollection(); Palette = createResourceDictionary(Col); System.Windows.Media.Brush BorderBrush = new SolidColorBrush(HUI_Util.ToMediaColor(Col[0])); ChartElem.BorderBrush = BorderBrush; ChartElem.Palette = Palette; } if (hasLegend) { Visibility LegendVis = Visibility.Hidden; if (Legend) { LegendVis = Visibility.Visible; } ChartElem.ChartLegendVisibility = LegendVis; } if (hasTitle) { Visibility TitleVis = Visibility.Hidden; if (Title) { TitleVis = Visibility.Visible; } ChartElem.ChartTitleVisibility = TitleVis; } }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { //set up the variables for GetData MainWindow mw = null; List <UIElement_Goo> elementsToAdd = new List <UIElement_Goo>(); Dictionary <string, UIElement_Goo> resultDict = new Dictionary <string, UIElement_Goo>(); //Get data from component if (!DA.GetData <MainWindow>("Window", ref mw)) { return; } if (!DA.GetDataList <UIElement_Goo>("Elements", elementsToAdd)) { return; } //clear out any old elements mw.clearElements(); if (DoVLChecking) { //check for any value listener connected to the same window var ActiveObjects = OnPingDocument().ActiveObjects(); var AllSources = HUI_Util.SourcesRecursive(Params.Input[1], ActiveObjects); var ValueListenerSources = AllSources.OfType <ValueListener_Component>(); if (ValueListenerSources.Count() != 0) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, VALUE_LISTENER_WARNING); } } //for all the elements, remove its parent, add it to the window, and add it to our tracking dictionary foreach (UIElement_Goo u in elementsToAdd) { if (u == null) { continue; } HUI_Util.removeParent(u.element); mw.AddElement(u.element); HUI_Util.AddToDict(u, resultDict); } //Pass out the added elements and their names. This is no longer so necessary now that listeners attach to elements directly. DA.SetDataList("Added Elements", resultDict); DA.SetDataList("Element Names", resultDict.Keys); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { object o = null; List <Mesh> m = new List <Mesh>(); List <System.Drawing.Color> cols = new List <System.Drawing.Color>(); if (!DA.GetData <object>("3D View", ref o)) { return; } DA.GetDataList <Mesh>("Mesh to display", m); //Get the 3d viewport object out of the input object HelixViewport3D vp3 = HUI_Util.GetUIElement <HelixViewport3D>(o); ModelVisual3D mv3 = GetModelVisual3D(vp3); List <ModelVisual3D> mv3s = GetModels(vp3); List <Material> mats = new List <Material>(); vp3.Children.Clear(); vp3.Children.Add(new SunLight()); if (!DA.GetDataList <System.Drawing.Color>("Mesh Colors", cols)) { foreach (ModelVisual3D mv30 in mv3s) { Model3DGroup model = mv30.Content as Model3DGroup; foreach (Model3D mod in model.Children) { if (mod is GeometryModel3D) { GeometryModel3D geom = mod as GeometryModel3D; mats.Add(geom.Material); } } } mv3.Content = new _3DViewModel(m, mats).Model; } else { mv3.Content = new _3DViewModel(m, cols).Model; } vp3.Children.Add(mv3); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { object ListObject = null; List <string> listContents = new List <string>(); List <bool> isSelected = new List <bool>(); if (!DA.GetData <object>("Checklist to modify", ref ListObject)) { return; } if (!DA.GetDataList <string>("New checklist contents", listContents)) { return; } //Get the scroll viewer ScrollViewer sv = HUI_Util.GetUIElement <ScrollViewer>(ListObject); //Get the itemsControl inside the scrollviewer ItemsControl ic = sv.Content as ItemsControl; if (!DA.GetDataList <bool>("Selected", isSelected)) { } //clear the items in there now ic.Items.Clear(); //set the new items for (int i = 0; i < listContents.Count; i++) { string item = listContents[i]; CheckBox cb = new CheckBox(); cb.Margin = new System.Windows.Thickness(2); cb.Content = item; if (isSelected.Count > 0) { // this is a cheap shortcut - but allows an approximation of "shortest list" behavior for cases of N and 1. If only one true is // passed, all boxes true, if a list is passed, will behave as expected. Only list-length mismatches will behave differently - and if // you're doing that, we have bigger problems anyway. bool isSel = isSelected[i % isSelected.Count]; cb.IsChecked = isSel; } ic.Items.Add(cb); } }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { List <UIElement_Goo> elementsToAdd = new List <UIElement_Goo>(); double width = 0; double height = 0; if (!DA.GetDataList <UIElement_Goo>("UI Elements", elementsToAdd)) { return; } if (!DA.GetData <double>("Width", ref width)) { return; } if (!DA.GetData <double>("Height", ref height)) { return; } //initialize the grid Grid grid = new Grid(); grid.HorizontalAlignment = HorizontalAlignment.Left; grid.VerticalAlignment = VerticalAlignment.Top; grid.Name = "GH_Grid"; grid.Width = width; grid.Height = height; //for all the elements to add foreach (UIElement_Goo u in elementsToAdd) { //make sure it doesn't already have a parent HUI_Util.removeParent(u.element); FrameworkElement fe = u.element as FrameworkElement; if (fe != null) { //set its alignment to be relative to upper left - this makes margin-based positioning easy fe.HorizontalAlignment = HorizontalAlignment.Left; fe.VerticalAlignment = VerticalAlignment.Top; } //add it to the grid grid.Children.Add(u.element); } //pass the grid out DA.SetData("Grid", new UIElement_Goo(grid, "Grid", InstanceGuid, DA.Iteration)); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { object obj = null; bool forward = false; bool back = false; bool refresh = false; string URL = ""; if (!DA.GetData <object>("Browser", ref obj)) { return; } //get the web browser object WebBrowser wb = HUI_Util.GetUIElement <WebBrowser>(obj); //Back if (DA.GetData <bool>("Back", ref back)) { if (wb.CanGoBack && back) { wb.GoBack(); } } //Forward if (DA.GetData <bool>("Forward", ref forward)) { if (wb.CanGoForward && forward) { wb.GoForward(); } } //Refresh if (DA.GetData <bool>("Refresh", ref refresh)) { if (refresh) { wb.Refresh(); } } //URL if (DA.GetData <string>("URL", ref URL)) { wb.Source = new Uri(URL); } }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { object tabContainer = null; List <string> tabNames = new List <string>(); List <bool> hideTabs = new List <bool>(); int selectIndex = -1; if (!DA.GetData("Tabbed View", ref tabContainer)) { return; } bool hasNames = DA.GetDataList("Tab Names", tabNames); bool hasHideTabs = DA.GetDataList("Show Tabs", hideTabs); bool hasIndex = DA.GetData(3, ref selectIndex); TabControl tabControl = HUI_Util.GetUIElement <TabControl>(tabContainer); for (int i = 0; i < tabControl.Items.Count; i++) { var item = tabControl.Items[i]; var tabItem = item as TabItem; if (hasNames && tabNames.Count > i) { tabItem.Header = tabNames[i]; } if (hasHideTabs && hideTabs.Count > i) { tabItem.Visibility = hideTabs[i] ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed; if (!hideTabs[i] && tabControl.SelectedIndex == i) { tabControl.SelectedIndex = (i + 1) % tabControl.Items.Count; } } } if (hasIndex) { tabControl.SelectedIndex = selectIndex; // In order to register the tab state properly, you must pull the tabControl into focus. // Otherwise, the next time you click on the contents it will revert to the last index position properly registered. tabControl.Focus(); } }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { object ListObject = null; List <string> listContents = new List <string>(); int selectedIndex = -1; if (!DA.GetData <object>("List to modify", ref ListObject)) { return; } if (!DA.GetDataList <string>("New list contents", listContents)) { return; } //the selector parent class includes both ListBoxes and ComboBoxes Selector sel = HUI_Util.GetUIElement <Selector>(ListObject); if (sel == null) { var listPanel = HUI_Util.GetUIElement <DockPanel>(ListObject); sel = listPanel.Children.OfType <Selector>().FirstOrDefault(); } if (!DA.GetData <int>("Selected Index", ref selectedIndex)) { selectedIndex = sel.SelectedIndex; } //clear out the existing list sel.Items.Clear(); //add all items in the input list as TextBlocks foreach (string item in listContents) { TextBlock textbox = new TextBlock(); textbox.Text = item; sel.Items.Add(textbox); } //set selected index sel.SelectedIndex = selectedIndex; }
protected override void SolveInstance(IGH_DataAccess DA) { object elem = null; if (!DA.GetData("UI Element", ref elem)) { return; } object unwrappedElem = HUI_Util.GetUIElement <UIElement>(elem); var type = unwrappedElem.GetType(); var props = type.GetProperties(); DA.SetDataList("Property Names", props.Select(p => p.Name)); DA.SetDataList("Property Types", props.Select(p => p.PropertyType.ToString())); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { object ImageObject = null; string newImagePath = ""; if (!DA.GetData <string>("New Image Path", ref newImagePath)) { return; } if (!DA.GetData <object>("Image to modify", ref ImageObject)) { return; } Image l = HUI_Util.GetUIElement <Image>(ImageObject); if (l != null) { HUI_Util.SetImageSource(newImagePath, l); } }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { List <UIElement_Goo> elementsToAdd = new List <UIElement_Goo>(); double width = 0; double height = 0; if (!DA.GetDataList <UIElement_Goo>("UI Elements", elementsToAdd)) { return; } if (!DA.GetData <double>("Width", ref width)) { return; } if (!DA.GetData <double>("Height", ref height)) { return; } //intitalize the viewbox Viewbox vb = new Viewbox(); vb.Width = width; vb.Height = height; vb.Stretch = Stretch.Uniform; //create a stackpanel to contain elements StackPanel sp = new StackPanel(); foreach (UIElement_Goo u in elementsToAdd) { //make sure elements don't already have a parent and add them to the stackpanel HUI_Util.removeParent(u.element); sp.Children.Add(u.element); } //place the stackpanel inside the viewbox vb.Child = sp; //pass out the viewbox object DA.SetData("ViewBox", new UIElement_Goo(vb, "ViewBox", InstanceGuid, DA.Iteration)); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { object LabelObject = null; string newLabelContents = ""; if (!DA.GetData <string>("New Label contents", ref newLabelContents)) { return; } if (!DA.GetData <object>("Label to modify", ref LabelObject)) { return; } Label l = HUI_Util.GetUIElement <Label>(LabelObject); //set label content if (l != null) { l.Content = newLabelContents; } }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { object TextBlockObject = null; string newTextBlockContents = ""; if (!DA.GetData <string>("New Text Block contents", ref newTextBlockContents)) { return; } if (!DA.GetData <object>("Text Block to modify", ref TextBlockObject)) { return; } //extract the TextBlock object from the generic object TextBlock l = HUI_Util.GetUIElement <TextBlock>(TextBlockObject); if (l != null) { //set its contents l.Text = newTextBlockContents; } }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { UIElement_Goo elementToAdd = null; double thickness = 5; Color color = Color.Black; double radius = 0; if (!DA.GetData <UIElement_Goo>("UI Element", ref elementToAdd)) { return; } if (!DA.GetData("Border Thickness", ref thickness)) { return; } if (!DA.GetData("Border Color", ref color)) { return; } if (!DA.GetData("Corner Radius", ref radius)) { return; } //intitalize the Border Border border = new Border { BorderThickness = new Thickness(thickness), BorderBrush = new SolidColorBrush(HUI_Util.ToMediaColor(color)), CornerRadius = new CornerRadius(radius) }; HUI_Util.removeParent(elementToAdd.element); border.Child = elementToAdd.element; //pass out the Border object DA.SetData("Border", new UIElement_Goo(border, "Border", InstanceGuid, DA.Iteration)); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { object TextBlockObject = null; string newLabelContents = ""; if (!DA.GetData <string>("New Text Box contents", ref newLabelContents)) { return; } if (!DA.GetData <object>("Text Box to modify", ref TextBlockObject)) { return; } // Since HUI textboxes are actually stackpanels with textboxes inside (since they may or may not also contain a button) // we have to grab the stackpanel first and then find the textbox inside it. Panel sp = HUI_Util.GetUIElement <Panel>(TextBlockObject); TextBox tb = HUI_Util.findTextBox(sp); if (tb != null) { //set the text of the textbox. tb.Text = newLabelContents; } }
protected override void SolveInstance(IGH_DataAccess DA) { object expanderElement = null; string newName = ""; bool expanded = false; if (!DA.GetData("Expander", ref expanderElement)) { return; } bool hasName = DA.GetData("Name", ref newName); bool hasExpanded = DA.GetData("Expanded Open", ref expanded); Expander e = HUI_Util.GetUIElement <Expander>(expanderElement); if (hasName) { e.Header = newName; } if (hasExpanded) { e.IsExpanded = expanded; } }