private static void OnIsOpenChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { RibbonContextMenu contextMenu = (RibbonContextMenu)d; if (!(bool)(e.NewValue)) { if (!contextMenu._ignoreDismissPopupsOnNextClose) { UIElement dismissPopupSource = contextMenu.GetDismissPopupSource(); if (CanRaiseDismissPopups(dismissPopupSource)) { // Raise DismissPopup on owner if can raise and if // was not asked to ignore. dismissPopupSource.RaiseEvent(new RibbonDismissPopupEventArgs(RibbonDismissPopupMode.Always)); ((Ribbon)(RibbonControlService.GetRibbon(dismissPopupSource))).RestoreFocusOnContextMenuClose(); } } else { contextMenu.RestoreFocusToRibbon(); contextMenu._ignoreDismissPopupsOnNextClose = false; } } else { contextMenu._ignoreDismissPopupsOnNextClose = false; } }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { DependencyObject d = value as DependencyObject; if (d != null) { Ribbon ribbon = RibbonControlService.GetRibbon(d); if (ribbon != null && !ribbon.ShowQuickAccessToolBarOnTop) { if (_mode == ConverterMode.Header) { return(ShowQATAboveText); } else { return(RibbonCommands.ShowQuickAccessToolBarAboveRibbonCommand); } } } if (_mode == ConverterMode.Header) { return(ShowQATBelowText); } else { return(RibbonCommands.ShowQuickAccessToolBarBelowRibbonCommand); } }
internal static RibbonContextMenu ChooseContextMenu(DependencyObject owner) { if (owner is Ribbon) { return(GetDefaultRibbonClientAreaContextMenu()); } else if (RibbonControlService.GetCanAddToQuickAccessToolBarDirectly(owner)) { if (owner is RibbonGallery) { return(GetGalleryContextMenu()); } else { if (RibbonControlService.GetIsInQuickAccessToolBar(owner)) { return(GetQATControlContextMenu()); } else { return(GetRibbonControlContextMenu()); } } } return(null); }
/// <summary> /// Tries to restore focus to the first focusable element across /// the ancestor chain of ContextMenuOriginalSource. Should /// be called only when Ribbon is supposed to retain the focus. /// </summary> private void RestoreFocusToRibbon() { DependencyObject current = GetDismissPopupSource(); if (current == null) { return; } Ribbon ribbon = RibbonControlService.GetRibbon(current); if (ribbon == null) { return; } while (current != null) { UIElement uie = current as UIElement; if (uie != null && uie.Focusable) { uie.Dispatcher.BeginInvoke( (Action) delegate() { if (!ribbon.IsKeyboardFocusWithin) { uie.Focus(); } }, DispatcherPriority.Input, null); break; } current = TreeHelper.GetParent(current); } }
private static object CoerceDefaultControlSizeDefinition(DependencyObject d, object baseValue) { if (baseValue == null) { RibbonControlGroup controlGroup = (RibbonControlGroup)d; RibbonImageSize imageSize = RibbonImageSize.Collapsed; bool isLabelVisible = false; int itemCount = controlGroup.Items.Count; bool childFound = false; // Get the largest ControlSizeDefinition variant for all // the child controls and construct a union ControlSizeDefinition. for (int i = 0; i < itemCount; i++) { RibbonControl ribbonControl = controlGroup.ItemContainerGenerator.ContainerFromIndex(i) as RibbonControl; if (ribbonControl != null && ribbonControl.Visibility != Visibility.Collapsed) { UIElement contentChild = ribbonControl.ContentChild; if (contentChild != null && contentChild.Visibility != Visibility.Collapsed) { RibbonControlSizeDefinition currentLargeCsd = RibbonControlService.GetDefaultControlSizeDefinition(contentChild); if (currentLargeCsd == null) { contentChild.CoerceValue(RibbonControlService.DefaultControlSizeDefinitionProperty); currentLargeCsd = RibbonControlService.GetDefaultControlSizeDefinition(contentChild); } if (currentLargeCsd != null) { childFound = true; if (imageSize == RibbonImageSize.Collapsed) { imageSize = currentLargeCsd.ImageSize; } else if (currentLargeCsd.ImageSize == RibbonImageSize.Large) { imageSize = RibbonImageSize.Large; } isLabelVisible |= currentLargeCsd.IsLabelVisible; if (isLabelVisible && imageSize == RibbonImageSize.Large) { break; } } } } } if (childFound) { return(RibbonControlSizeDefinition.GetFrozenControlSizeDefinition(imageSize, isLabelVisible)); } } return(baseValue); }
private static object CoerceControlSizeDefinition(DependencyObject d, object baseValue) { if (baseValue == null) { RibbonControlSizeDefinition defaultControlSizeDefinition = RibbonControlService.GetDefaultControlSizeDefinition(d); if (defaultControlSizeDefinition == null) { d.CoerceValue(DefaultControlSizeDefinitionProperty); defaultControlSizeDefinition = RibbonControlService.GetDefaultControlSizeDefinition(d); } return(defaultControlSizeDefinition); } return(baseValue); }
/// <summary> /// Property changed callback for tooltip PlacementTarget property. /// </summary> private static void OnPlacementTargetPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { RibbonToolTip ribbonToolTip = (RibbonToolTip)d; UIElement target = e.NewValue as UIElement; if (target == null) { ribbonToolTip.Ribbon = null; } else { ribbonToolTip.Ribbon = RibbonControlService.GetRibbon(target); } }
private static void UpdateDefaultControlSizeDefinition(DependencyObject d) { d.CoerceValue(DefaultControlSizeDefinitionProperty); // If the element belongs to a ControlGroup, then // coerce DefaultControlSizeDefinition for the ControlGroup too. if (RibbonControlService.GetIsInControlGroup(d)) { RibbonControlGroup controlGroup = TreeHelper.FindVisualAncestor <RibbonControlGroup>(d); if (controlGroup != null) { controlGroup.CoerceValue(DefaultControlSizeDefinitionProperty); } } }
// Determine whether the QAT contains an element with the given QAT ID. internal bool ContainsId(object targetID) { foreach (object o in this.Items) { DependencyObject dependencyObject = o as DependencyObject; if (dependencyObject != null) { object currentID = RibbonControlService.GetQuickAccessToolBarId(dependencyObject); if (object.Equals(currentID, targetID)) { return(true); } } } return(false); }
private void TransferPseudoInheritedProperties() { if (_templateRoot != null) { // Ribbon is an inherited property. In non-MVVM scenarios where // controls are directly added under RibbonGroup in XAML, RibbonGroup // is the logical parent of those controls and they get the value // of RibbonParent set from their logical parent. When a RibbonGroup // get collapsed and its template changes, due to a bug in framework // the inheritance value of those controls is lost during visual tree // change and never again gets updated. The workaround is to set the // local value on those controls from RibbonContentPresenter which // would be their visual parent. This works because Ribbon property is // readonly. RibbonControlService.SetRibbon(_templateRoot, RibbonControlService.GetRibbon(this)); RibbonHelper.TransferPseudoInheritedProperties(this, _templateRoot); } }
private static object CoerceDefaultControlSizeDefinition(DependencyObject d, object baseValue) { if (baseValue == null) { RibbonImageSize imageSize = RibbonImageSize.Collapsed; if (RibbonControlService.GetLargeImageSource(d) != null) { imageSize = RibbonImageSize.Large; } else if (RibbonControlService.GetSmallImageSource(d) != null) { imageSize = RibbonImageSize.Small; } bool isLabelVisible = !string.IsNullOrEmpty(RibbonControlService.GetLabel(d)); return(RibbonControlSizeDefinition.GetFrozenControlSizeDefinition(imageSize, isLabelVisible)); } return(baseValue); }
private static bool CanRaiseDismissPopups(UIElement dismissPopupSource) { // Contextmenu raises DismissPopup event on the source only // if it is in a popup and is in a Ribbon. if (dismissPopupSource == null || RibbonControlService.GetRibbon(dismissPopupSource) == null) { return(false); } Popup ancestorPopup = TreeHelper.FindAncestor(dismissPopupSource, delegate(DependencyObject element) { return(element is Popup); }) as Popup; if (ancestorPopup == null || !ancestorPopup.IsOpen) { return(false); } return(true); }
/// <summary> /// Helper method which scrolls item at given index into view. /// Can be used as a dispatcher operation. /// </summary> /// <param name="arg"></param> /// <returns></returns> private object ScrollContainerIntoView(object arg) { int index = (int)arg; FrameworkElement element = ItemContainerGenerator.ContainerFromIndex(index) as FrameworkElement; if (element != null) { element.BringIntoView(); // If there is a margin on TabHeader on the end, BringIntoView call // may not scroll to the end. Explicitly scroll to end in such cases. IScrollInfo scrollInfo = InternalItemsHost as IScrollInfo; if (scrollInfo != null) { ScrollViewer scrollViewer = scrollInfo.ScrollOwner; if (scrollViewer != null) { Ribbon ribbon = RibbonControlService.GetRibbon(this); if (ribbon != null) { int displayIndex = ribbon.GetTabDisplayIndexForIndex(index); if (displayIndex == 0) { // If this tab header is the first tab header displayed // then scroll to the left end. scrollViewer.ScrollToLeftEnd(); } else if (ribbon.GetTabIndexForDisplayIndex(displayIndex + 1) < 0) { // If this tab header is the last tab header displayed // then scroll to the right end. scrollViewer.ScrollToRightEnd(); } } } } } return(null); }
private UIElement GetDismissPopupSource() { UIElement placementTarget = PlacementTarget; if (placementTarget == null) { return(null); } Ribbon ribbon = RibbonControlService.GetRibbon(placementTarget); if (ribbon == null) { return(null); } // The original source for corresponding ContextMenuOpening will // be the original source for DismissPopup event. UIElement returnValue = ribbon.ContextMenuOriginalSource; if (returnValue == null) { returnValue = placementTarget; } return(returnValue); }