private void TracePropertyChanged(BreadcrumbItem sender, AvaloniaPropertyChangedEventArgs e) { BreadcrumbItem item = sender as BreadcrumbItem; RoutedPropertyChangedEventArgs <object> args = new RoutedPropertyChangedEventArgs <object>(e.OldValue, e.NewValue, TraceChangedEvent); item.RaiseEvent(args); }
private void breadcrumbItemSelectionChangedEvent(object sender, RoutedEventArgs e) { BreadcrumbItem parent = e.Source as BreadcrumbItem; if (parent != null && parent.SelectedBreadcrumb != null) { OnPopulateItems(parent.SelectedBreadcrumb); } }
private void SelectTraceCommandExecuted(object sender) { BreadcrumbItem item = sender as BreadcrumbItem; if (item != null) { item.SelectedItem = null; } }
private void OnSelectedBreadcrumbPropertyChanged(BreadcrumbBar bar, AvaloniaPropertyChangedEventArgs e) { BreadcrumbItem selected = e.NewValue as BreadcrumbItem; bar.IsRootSelected = selected == bar.RootItem; if (bar.IsInitialized) { RoutedPropertyChangedEventArgs <BreadcrumbItem> args = new RoutedPropertyChangedEventArgs <BreadcrumbItem>(e.OldValue as BreadcrumbItem, e.NewValue as BreadcrumbItem, BreadcrumbBar.SelectedBreadcrumbChangedEvent); bar.RaiseEvent(args); } }
/// <summary> /// creates the initial Breadcrumb item /// </summary> /// <param name="dataContext"></param> /// <returns></returns> internal static BreadcrumbItem CreateInitialItem(object dataContext) { BreadcrumbItem item = dataContext as BreadcrumbItem; if (item == null && dataContext != null) { item = new BreadcrumbItem(); item.Items = dataContext as IEnumerable; } return(item); }
/// <summary> /// Creates a new BreadcrumbItem out of the specified data. /// </summary> /// <param name="dataContext">The DataContext for the BreadcrumbItem</param> /// <returns>DataContext if dataContext is a Breadcrumbitem, otherwhise a new BreadcrumbItem.</returns> public static BreadcrumbItem CreateItem(object dataContext) { BreadcrumbItem item = dataContext as BreadcrumbItem; if (item == null && dataContext != null) { item = new BreadcrumbItem(); item.DataContext = dataContext; } return(item); }
private void breadcrumbItemDropDownChangedEvent(object sender, RoutedEventArgs e) { BreadcrumbItem breadcrumb = e.Source as BreadcrumbItem; if (breadcrumb.IsDropDownPressed) { OnBreadcrumbItemDropDownOpened(e); } else { OnBreadcrumbItemDropDownClosed(e); } }
/// <summary> /// Build the list of traces for the overflow button. /// </summary> private void BuildTraces() { BreadcrumbItem item = RootItem; traces.Clear(); if (item != null && item.IsOverflow) { foreach (object trace in item.Items) { MenuItem menuItem = new MenuItem();//new RibbonMenuItem(); menuItem.Tag = trace; BreadcrumbItem bcItem = item.ContainerFromItem(trace); menuItem.Click += menuItem_Click; menuItem.Icon = GetImage(bcItem != null ? bcItem.Image : null); if (trace == RootItem.SelectedItem) { menuItem.FontWeight = FontWeight.Bold; } traces.Add(menuItem); if (bcItem != null) { menuItem.Header = bcItem.TraceValue; } } traces.Insert(0, new Separator()); MenuItem rootMenuItem = new MenuItem();//new RibbonMenuItem(); rootMenuItem.Header = item.TraceValue; rootMenuItem.Command = SelectRootCommand; rootMenuItem.CommandParameter = item; rootMenuItem.Icon = GetImage(item.Image); traces.Insert(0, rootMenuItem); } item = item != null ? item.SelectedBreadcrumb : null; while (item != null) { if (!item.IsOverflow) { break; } MenuItem traceMenuItem = new MenuItem(); traceMenuItem.Header = item.TraceValue; traceMenuItem.Command = SelectRootCommand; traceMenuItem.CommandParameter = item; traceMenuItem.Icon = GetImage(item.Image); traces.Insert(0, traceMenuItem); item = item.SelectedBreadcrumb; } }
/// <summary> /// Generates a new BreadcrumbItem out of the specified item. /// </summary> /// <param name="item">The item for which to create a new BreadcrumbItem.</param> /// <returns>Item, if item is a BreadcrumbItem, otherwhise a newly created BreadcrumbItem.</returns> public BreadcrumbItem ContainerFromItem(object item) { BreadcrumbItem result = item as BreadcrumbItem; if (result == null) { result = CreateItem(item); if (result != null) { LogicalChildren.Add(result); result.ApplyTemplate(); } } return(result); }
private void breadcrumbItemSelectedItemChanged(object sender, RoutedEventArgs e) { BreadcrumbItem breadcrumb = e.Source as BreadcrumbItem; if (breadcrumb != null && breadcrumb.SelectedBreadcrumb != null) { breadcrumb = breadcrumb.SelectedBreadcrumb; } SelectedBreadcrumb = breadcrumb; if (SelectedBreadcrumb != null) { SelectedItem = SelectedBreadcrumb.Data; } Path = GetEditPath(); }
/// <summary> /// Occurs when the IsDropDownPressed property is changed. /// </summary> /// <param name="o"></param> /// <param name="e"></param> private void DropDownPressedPropertyChanged(BreadcrumbItem o, AvaloniaPropertyChangedEventArgs e) { if (e.NewValue is bool) { bool value = (bool)e.NewValue; if (lastValue == value) { return; } BreadcrumbItem item = o as BreadcrumbItem; item.OnDropDownPressedChanged(); lastValue = value; } }
protected override void OnTemplateApplied(TemplateAppliedEventArgs e) { base.OnTemplateApplied(e); comboBox = e.NameScope.Find <ComboBox>(partComboBox); rootButton = e.NameScope.Find <BreadcrumbButton>(partRoot); ToggleButton toggleButton = e.NameScope.Find <ToggleButton>("dropDown"); //toggleButton.Checked += (o, e) => //{ // if (toggleButton.IsChecked == true) // { // IsDropDownOpen = true; // } // else // { // IsDropDownOpen = false; // } //}; if (comboBox != null) { //comboBox.DropDownClosed += new EventHandler(comboBox_DropDownClosed); comboBox.PropertyChanged += ComboBox_PropertyChanged; //comboBox.IsKeyboardFocusWithinChanged += new DependencyPropertyChangedEventHandler(comboBox_IsKeyboardFocusWithinChanged); comboBox.KeyDown += comboBox_KeyDown; PseudoClasses.Set(":comboBoxIsVisible", comboBox.IsVisible); } if (rootButton != null) { rootButton.PointerPressed += rootButton_Click; } BreadcrumbItem breadcrumbItem = Content as BreadcrumbItem; _isInitial = true; RaisePropertyChanged(RootProperty, null, breadcrumbItem.Items); _isInitial = false; //RaisePropertyChanged(PathProperty, string.Empty, Path); }
private MenuItem CreateMenuItem(object item) { //RibbonMenuItem menuItem = new RibbonMenuItem(); MenuItem menuItem = new MenuItem(); menuItem.DataContext = item; BreadcrumbItem bi = item as BreadcrumbItem; if (bi == null) { BreadcrumbItem parent = TemplatedParent as BreadcrumbItem; if (parent != null) { bi = parent.ContainerFromItem(item); } } if (bi != null) { menuItem.Header = bi.TraceValue; } Image image = new Image(); image.Source = bi != null ? bi.Image : null; //image.SnapsToDevicePixels = true; image.Stretch = Stretch.Fill; image.VerticalAlignment = Layout.VerticalAlignment.Center; image.HorizontalAlignment = Layout.HorizontalAlignment.Center; image.Width = 16; image.Height = 16; menuItem.Icon = image; menuItem.Click += item_Click;// += new RoutedEventHandler(item_Click); if (item != null && item.Equals(SelectedItem)) { menuItem.FontWeight = FontWeight.Bold; } menuItem.ItemTemplate = ItemTemplate; //menuItem.ItemTemplateSelector = ItemTemplateSelector; //contextMenu.Items.OfType<object>().ToList().Add(menuItem); return(menuItem); }
/// <summary> /// Gets the item that represents the specified trace otherwise null. /// </summary> /// <param name="trace">The Trace property of the associated BreadcrumbItem.</param> /// <returns>An object included in Items, otherwise null.</returns> public object GetTraceItem(string trace) { this.ApplyTemplate(); foreach (object item in Items) { BreadcrumbItem bcItem = ContainerFromItem(item); if (bcItem != null) { ApplyProperties(item); string value = bcItem.TraceValue; if (value != null && value.Equals(trace, StringComparison.InvariantCultureIgnoreCase)) { return(item); } } else { return(null); } } return(null); }
/// <summary> /// Gets the path of the specified BreadcrumbItem. /// </summary> /// <param name="item">The BreadrumbItem for which to determine the path.</param> /// <returns>The path of the BreadcrumbItem which is the concenation of all Traces from all selected breadcrumbs.</returns> public string PathFromBreadcrumbItem(BreadcrumbItem item) { StringBuilder sb = new StringBuilder(); while (item != null) { if (item == RootItem && sb.Length > 0) { break; } if (sb.Length > 0) { sb.Insert(0, SeparatorString); } sb.Insert(0, item.TraceValue); item = item.ParentBreadcrumbItem; } PathConversionEventArgs e = new PathConversionEventArgs(ConversionMode.DisplayToEdit, sb.ToString(), Root, PathConversionEvent); RaiseEvent(e); return(e.EditPath); }
/// <summary> /// Gets the display path from the traces of the BreacrumbItems. /// </summary> /// <returns></returns> public string GetDisplayPath() { string separator = SeparatorString; StringBuilder sb = new StringBuilder(); BreadcrumbItem item = RootItem; int index = 0; while (item != null) { if (sb.Length > 0) { sb.Append(separator); } if (index >= BreadcrumbsToHide || item.SelectedItem == null) { sb.Append(item.GetTracePathValue()); } index++; item = item.SelectedBreadcrumb; } return(sb.ToString()); }
public BreadcrumbItemEventArgs(BreadcrumbItem item, RoutedEvent routedEvent) : base(routedEvent) { Item = item; }
private void HeaderPropertyChanged(BreadcrumbItem sender, AvaloniaPropertyChangedEventArgs e) { BreadcrumbItem item = sender as BreadcrumbItem; }
private void SelectedBreadcrumbPropertyChanged(BreadcrumbItem sender, AvaloniaPropertyChangedEventArgs e) { BreadcrumbItem item = sender as BreadcrumbItem; item.OnSelectedBreadcrumbChanged(e.OldValue, e.NewValue); }
/// <summary> /// Occurs when the Overflow property is changed. /// </summary> /// <param name="o"></param> /// <param name="e"></param> private void OverflowPropertyChanged(BreadcrumbItem o, AvaloniaPropertyChangedEventArgs e) { BreadcrumbItem item = o as BreadcrumbItem; item.OnOverflowChanged((bool)e.NewValue); }
/// <summary> /// Appies the binding to the breadcrumb item. /// </summary> public void ApplyBinding() { object item = DataContext; if (item == null) { return; } BreadcrumbItem root = this; IDataTemplate template = HeaderTemplate; //DataTemplateSelector templateSelector = HeaderTemplateSelector; //if (templateSelector != null) //{ // template = templateSelector.SelectTemplate(item, root); //} if (template == null) { //DataTemplateKey key = GetResourceKey(item); //if (key != null) //{ // this.TryFindResource(key, template); //} } root.SelectedItem = null; TreeDataTemplate hdt = template as TreeDataTemplate; if (template != null) { //root.Header = template.LoadContent(); } else { root.Header = item; } root.DataContext = item; if (hdt != null) { // bind the Items to the hierarchical data template: root.Bind(BreadcrumbItem.ItemsProperty, hdt.ItemsSource); } BreadcrumbBar bar = BreadcrumbBar; if (bar != null) { if (TraceBinding == null) { TraceBinding = bar.TraceBinding; } if (ImageBinding == null) { ImageBinding = bar.ImageBinding; } } if (TraceBinding != null) { root.Bind(BreadcrumbItem.TraceProperty, TraceBinding); } if (ImageBinding != null) { root.Bind(BreadcrumbItem.ImageProperty, ImageBinding); } ApplyProperties(item); }
/// <summary> /// Occurs when the Root property is changed. /// </summary> /// <param name="oldValue"></param> /// <param name="newValue"></param> protected virtual void OnRootChanged(BreadcrumbBar bar, object oldValue, object newValue) { if (_isInitial == false) { newValue = GetFirstItem(newValue); } BreadcrumbItem oldRoot = oldValue as BreadcrumbItem; if (oldRoot != null) { oldRoot.IsRoot = false; } if (newValue == null) { RootItem = null; Path = null; } else { BreadcrumbItem root = newValue as BreadcrumbItem; if (root == null) { if (_isInitial == false) { root = BreadcrumbItem.CreateItem(newValue); } else { root = BreadcrumbItem.CreateInitialItem(newValue); } } if (root != null) { root.IsRoot = true; } if (oldValue != null) { this.LogicalChildren.Remove((ILogical)oldValue); } RootItem = root; if (root != null) { //bool result = LogicalTree.LogicalExtensions.GetLogicalParent(root as ILogical) == null; ////if (LogicalTree.LogicalExtensions.GetLogicalParent(root as ILogical) == null) //{ // this.LogicalChildren.Remove(root); // this.LogicalChildren.Add(root); //} } SelectedItem = root != null ? root.DataContext : null; if (IsInitialized) { SelectedBreadcrumb = root; } else { SelectedBreadcrumb = root; } } }
/// <summary> /// Occurs when the selected item of an embedded BreadcrumbItem is changed. /// </summary> /// <param name="oldvalue"></param> /// <param name="newValue"></param> protected virtual void OnRootItemChanged(BreadcrumbItem oldValue, BreadcrumbItem newValue) { }
/// <summary> /// Traces the specified path and builds the associated BreadcrumbItems. /// </summary> /// <param name="path">The traces separated by the SepearatorString property.</param> private bool BuildBreadcrumbsFromPath(string newPath) { PathConversionEventArgs e = new PathConversionEventArgs(ConversionMode.EditToDisplay, newPath, Root, PathConversionEvent); RaiseEvent(e); newPath = e.DisplayPath; BreadcrumbItem item = RootItem; if (item == null) { this.Path = null; return(false); } newPath = RemoveLastEmptySeparator(newPath); string[] traces = newPath.Split(new string[] { SeparatorString }, StringSplitOptions.RemoveEmptyEntries); if (traces.Length == 0) { RootItem.SelectedItem = null; } int index = 0; List <int> itemIndex = new List <int>(); // if the root is specified as first trace, then skip: int length = traces.Length; int max = BreadcrumbsToHide; if (traces.Length > index && max > 0 && traces[index] == (RootItem.TraceValue)) { length--; index++; max--; } for (int i = index; i < traces.Length; i++) { if (item == null) { break; } string trace = traces[i]; OnPopulateItems(item); object next = item.GetTraceItem(trace); if (next == null) { break; } itemIndex.Add(item.Items.OfType <object>().ToList().IndexOf(next)); BreadcrumbItem container = item.ContainerFromItem(next); item = container; } if (length != itemIndex.Count) { //recover the last path: Path = GetDisplayPath(); return(false); } // temporarily remove the SelectionChangedEvent handler to minimize processing of events while building the breadcrumb items: RemoveHandler(BreadcrumbItem.SelectionChangedEvent, breadcrumbItemSelectedItemChanged); try { item = RootItem; for (int i = 0; i < itemIndex.Count; i++) { if (item == null) { break; } item.SelectedIndex = itemIndex[i]; item = item.SelectedBreadcrumb; } if (item != null) { item.SelectedItem = null; } SelectedBreadcrumb = item; SelectedItem = item != null ? item.Data : null; } finally { AddHandler(BreadcrumbItem.SelectionChangedEvent, breadcrumbItemSelectedItemChanged); } return(true); }
/// <summary> /// Occurs before acessing the Items property of a BreadcrumbItem. This event can be used to populate the Items on demand. /// </summary> protected virtual void OnPopulateItems(BreadcrumbItem item) { BreadcrumbItemEventArgs args = new BreadcrumbItemEventArgs(item, BreadcrumbBar.PopulateItemsEvent); RaiseEvent(args); }
/// <summary> /// item which belongs to the breadcrumpitem /// </summary> /// <param name="item"></param> /// <param name="breadcrumb"></param> /// <param name="routedEvent"></param> public ApplyPropertiesEventArgs(object item, BreadcrumbItem breadcrumb, RoutedEvent routedEvent) : base(routedEvent) { Item = item; Breadcrumb = breadcrumb; }