C# TreeViewItem.SetValue方法代码示例

        public static bool WalkTreeViewItem(TreeView tree, TreeViewItem treeViewItem, object selectedValue)
        {
            if (treeViewItem.DataContext == selectedValue)
            {
                treeViewItem.SetValue(TreeViewItem.IsSelectedProperty, true);
                treeViewItem.Focus();
                treeViewItem.BringIntoView();
                return true;
            }
            var itemsHostProperty = treeViewItem.GetType().GetProperty("ItemsHost", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);

            var itemsHost = itemsHostProperty?.GetValue(treeViewItem, null) as Panel;

            if (itemsHost == null)
            {
                return false;
            }

            foreach (var item in itemsHost.Children.OfType<TreeViewItem>())
            {
                var oldExpanded = item.IsExpanded;
                item.IsExpanded = true;
                item.UpdateLayout();
                if (WalkTreeViewItem(tree, item, selectedValue))
                {
                    return true;
                }
                item.IsExpanded = oldExpanded;
            }

            return false;
        }

        /// <summary>
        /// Gets the value of the ConnectingLineInfo attached property for a
        /// specified TreeViewItem.
        /// </summary>
        /// <param name="element">
        /// The TreeViewItem from which the property value is read.
        /// </param>
        /// <returns>
        /// The ConnectingLineInfo property value for the TreeViewItem.
        /// </returns>
        internal static TreeViewItemConnectingLineInfo GetConnectingLineInfo(TreeViewItem element)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }
            
            // Get the info and create on demand if necessary
            TreeViewItemConnectingLineInfo info = element.GetValue(ConnectingLineInfoProperty) as TreeViewItemConnectingLineInfo;
            if (info == null)
            {
                info = new TreeViewItemConnectingLineInfo(element);
                element.SetValue(ConnectingLineInfoProperty, info);
            }

            return info;
        }

 public static void SetIsBroughtIntoViewWhenSelected(TreeViewItem treeViewItem, bool value)
 {
     treeViewItem.SetValue(IsBroughtIntoViewWhenSelectedProperty, value);
 }

 public static void SetIsTreeViewItemDropOver(TreeViewItem item, bool value)
 {
     item.SetValue(IsTreeViewItemDropOverProperty, value);
 }

        public static void SetIsItemSelected(TreeViewItem element, Boolean value)
        {
            if (element == null) return;

            element.SetValue(IsItemSelectedProperty, value);
        }

 public static void SetBringSelectionIntoView(TreeViewItem treeViewItem, bool value)
 {
     treeViewItem.SetValue(BringSelectionIntoViewProperty, value);
 }

 public static void SetIsFiltered(TreeViewItem item, bool value)
 {
     item.SetValue(IsFilteredProperty, value);
 }

 public static void SetEnableContextMenuWorkaround(
     TreeViewItem treeViewItem, bool value) {
     treeViewItem.SetValue(EnableContextMenuWorkaroundProperty, value);
 }

 public static void SetEnableFullRowSelection(
     TreeViewItem treeViewItem, bool value) {
     treeViewItem.SetValue(EnableFullRowSelectionProperty, value);
 }

 public static void SetBringIntoViewWhenSelected(TreeViewItem treeViewItem, bool value)
 {
     treeViewItem.SetValue(BringIntoViewWhenSelectedProperty, value);
 }

        static void SetIsChecked(TreeViewItem item, bool? value, bool updateChildren, bool updateParent)
        {
            if (value == GetIsSelected(item))
                return;

            item.SetValue(IsSelectedProperty, value);

            if (updateChildren && value.HasValue)
            {
                foreach (var treeViewItem in GetChildren(item))
                {
                    SetIsChecked(treeViewItem,value, true, false);
                }
            }

            if (updateParent && GetParentTreeViewItem(item)!= null)
                VerifyCheckState(GetParentTreeViewItem(item));
        }

 /// <summary>
 /// Sets the value of the AssociatedToolbarItem attached property to a specified TreeViewItem.
 /// </summary>
 /// <param name="element">The TreeViewItem to which the attached property is written.</param>
 /// <param name="value">The needed AssociatedToolbarItem value.</param>
 internal static void SetAssociatedToolbarItem(TreeViewItem element, AddToolbarItem value)
 {
     if (element == null)
     {
         throw new ArgumentNullException("element");
     }
     element.SetValue(AssociatedToolbarItemProperty, value);
 }

        void resource_GetChildResourcesCompleted(object sender, GetChildResourcesCompletedEventArgs e)
        {
            TreeViewItem tvi = null;
            string childName = "";

            object[] userState = e.UserState as object[];

            IDataSourceWithResources dataSource = userState[1] as IDataSourceWithResources;
            if (dataSource == null)
                return;

            // If the element at [0] is a tree view item, then this is a standard expand action on a parent node and
            // the logic flow is as it was before: remove current contents, add from array
            tvi = userState[0] as TreeViewItem;
            if (tvi != null)
            {
                tvi.Items.Clear();
            }
            else
            {
                // If the item we are adding to is the root (TreeView) then there are no children, but we are instead using the
                // progress indicator and must clear this here.
                showHideProgressIndicator(true);
                enableDisableUrlEntryUI(false);

                // Fabricate parent node and include connection, etc. so that when this node is expanded or child nodes are
                // referenced, the infrastructure will be in place to make existing logic work to obtain child information
                Resource parentResource = userState[2] as Resource;
                tvi = new TreeViewItem
                {
                    HeaderTemplate = LayoutRoot != null ? LayoutRoot.Resources["ResourceNodeDataTemplate"] as DataTemplate : null,
                    Header = parentResource,
                    DataContext = parentResource,
                    IsExpanded = true,
                    IsSelected = true,
                    Style = LayoutRoot != null ? LayoutRoot.Resources["TreeViewItemStyle"] as Style : null,
                };
                Connection connection = userState[3] as Connection;
                tvi.SetValue(TreeViewItemExtensions.ConnectionProperty, connection);
                treeResources.Items.Add(tvi);

                // If the parent item "tag" is assigned a value, store it for comparison against all child elements so that
                // the proper child element can be automatically selected. This is used when the URL contains the child
                // element of a map service, gp service, feature service, etc.
                if (parentResource.Tag != null)
                {
                    childName = parentResource.Tag as string;
                }
            }

            if (e.ChildResources == null)
                return;

            foreach (Resource childResource in e.ChildResources)
            {
                TreeViewItem treeViewItem = new TreeViewItem
                {
                    HeaderTemplate = LayoutRoot != null ? LayoutRoot.Resources["ResourceNodeDataTemplate"] as DataTemplate : null,
                    Header = childResource,
                    DataContext = childResource,
                    IsExpanded = false,
                    Style = LayoutRoot != null ? LayoutRoot.Resources["TreeViewItemStyle"] as Style : null,
                };
                if (childResource.ResourceType == ResourceType.Layer || childResource.ResourceType == ResourceType.EditableLayer)
                {
                    treeViewItem.SetValue(ToolTipService.ToolTipProperty, childResource.ResourceType == ResourceType.Layer ? Strings.MapLayer : Strings.FeatureLayer);
                }
                if (!string.IsNullOrWhiteSpace(childResource.DisplayName))
                {
                    string parentAutomationId = tvi.GetValue(System.Windows.Automation.AutomationProperties.AutomationIdProperty) as string;
                    if (parentAutomationId == null)
                        parentAutomationId = string.Empty;
                    treeViewItem.SetValue(System.Windows.Automation.AutomationProperties.AutomationIdProperty, parentAutomationId + childResource.DisplayName + childResource.ResourceType);
                }

                bool hasChildResource = dataSource.SupportsChildResources(childResource, filter);
                if (hasChildResource)
                {
                    treeViewItem.Items.Add(createRetrievingNode());
                    treeViewItem.Expanded += new RoutedEventHandler(resourceNode_Expanded);
                }

                // If a child Id was successfully extracted from the parent resource, this means there should be a child
                // resource with the same id and we need to select this as the initial URL indicated the desire to use
                // this child resource.
                if (!String.IsNullOrEmpty(childName))
                {
                    if (childResource.ResourceType == ResourceType.GPTool || childResource.ResourceType == ResourceType.DatabaseTable)
                    {
                        if (String.Compare(childName, childResource.DisplayName) == 0)
                            treeViewItem.IsSelected = true;
                    }
                    else if (childResource.ResourceType == ResourceType.Layer)
                    {
                        if (childResource.Tag != null)
                        {
                            int nodeId = (int)childResource.Tag;
                            string nodeName = String.Format("{0}", nodeId);
                            if (String.Compare(childName, nodeName) == 0)
                                treeViewItem.IsSelected = true;
//.........这里部分代码省略.........

        void dataSource_GetCatalogCompleted(object sender, GetCatalogCompletedEventArgs e)
        {
            enableDisableUrlEntryUI(false);

            object[] userState = e.UserState as object[];
            if (userState == null || userState.Length < 2)
                return;

            Connection connection = userState[0] as Connection;
            if (connection == null)
                return;

            if (e.ChildResources == null)
                return;

            if (treeResources == null)
                return;

            ESRI.ArcGIS.Mapping.Core.DataSources.DataSource ds = DataSourceProvider.CreateNewDataSourceForConnectionType(connection.ConnectionType);
            if (ds == null)
                return;

            IDataSourceWithResources dsWithResource = ds as IDataSourceWithResources;

            treeResources.Items.Clear();

            foreach (Resource childResource in e.ChildResources)
            {
                TreeViewItem treeViewItem = new TreeViewItem
                {
                    HeaderTemplate = LayoutRoot != null ? LayoutRoot.Resources["ResourceNodeDataTemplate"] as DataTemplate : null,
                    Header = childResource,
                    DataContext = childResource,
                    IsExpanded = false,
                    Style = LayoutRoot != null ? LayoutRoot.Resources["TreeViewItemStyle"] as Style : null,
                };
                if(!string.IsNullOrWhiteSpace(childResource.DisplayName))
                    treeViewItem.SetValue(System.Windows.Automation.AutomationProperties.AutomationIdProperty, childResource.DisplayName);
                
                treeViewItem.SetValue(TreeViewItemExtensions.ConnectionProperty, connection);
                if (dsWithResource != null && dsWithResource.SupportsChildResources(childResource, filter))
                {
                    treeViewItem.Items.Add(createRetrievingNode());
                    treeViewItem.Expanded += new RoutedEventHandler(resourceNode_Expanded);
                }
                treeResources.Items.Add(treeViewItem);
            }

            showHideProgressIndicator(true);
            bool addConnection = true;
            if (treeResources.Items.Count == 0)
            {
                if(!string.IsNullOrEmpty(e.Error))
                    MessageBoxDialog.Show(e.Error, ESRI.ArcGIS.Mapping.Controls.Resources.Strings.BrowseDialogGeographicDataNotFound, MessageBoxButton.OK);
                else if ((Filter & Filter.GeoprocessingServices) == Filter.GeoprocessingServices)
                    MessageBoxDialog.Show(string.Format(LocalizableStrings.NoGPServicesFound, connection.Name));
                else
                    MessageBoxDialog.Show(string.Format(LocalizableStrings.NoMapServicesFound, connection.Name));
                addConnection = false;
            }

            OnGetCatalogCompleted(e);
            bool isNewConnection = (bool)userState[1];
            if (isNewConnection)
            {
                if (addConnection)
                {
                    Connections.Add(connection);
                    if (ConnectionsProvider != null)
                        ConnectionsProvider.AddConnection(connection); // inform the provider about the new connection
                    OnConnectionAdded(new ConnectionAddedEventArgs() { Connection = connection });
                }
            }
        }