究竟是什么标识了网站访问者？

Question

trydex

Asked:2020-07-23 22:58:56 +0000 UTC2020-07-23 22:58:56 +0000 UTC 2020-07-23 22:58:56 +0000 UTC

在 TabControl 中更改活动选项卡时重置 DataTemplate 中的属性

772

该程序使用TabControl并且它的每个选项卡都由一个带有表格的用户控件表示DataGrid。

当活动选项卡改变时，ItemsSource每次都重新设置该属性，导致滚动条和表格中所有选中的行都丢失之前的状态，每次加载都需要等待一段时间数据。

代码没有任何变化。

问题是什么？

主窗口：

<TabControl ItemsSource="{Binding Tabs}">
    <TabControl.ItemContainerStyle>
        <Style TargetType="{x:Type TabItem}">
            <Setter Property="Header" Value="{Binding Title}" />
            <Setter Property="ContentTemplate">
                <Setter.Value>
                    <DataTemplate>
                        <wpfTemp:MyDataGrid ItemsSource="{Binding Items}" />
                    </DataTemplate>
                </Setter.Value>
            </Setter>
        </Style>
    </TabControl.ItemContainerStyle>
</TabControl>

用户控制：

<DataGrid ItemsSource="{Binding ItemsSource, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type UserControl}}}"
          SelectionMode="Extended"
          AutoGenerateColumns="False">
    <DataGrid.Columns>
        <DataGridTextColumn Header="Number" Binding="{Binding}" />
    </DataGrid.Columns>
</DataGrid>

3 个回答

Voted

trydex · Answer 1 · 2020-07-24T14:18:26Z

多亏了英文版 SO 上的这个答案，问题才得以解决。谢谢@和尚。

XAML：

<TabControl ikriv:TabContent.IsCached="True">
    <ikriv:TabContent.Template>
        <DataTemplate>
            <!-- custom content template goes here -->
        </DataTemplate>
    </ikriv:TabContent.Template>
</TabControl>

代码隐藏：

public static class TabContent
{
    public static bool GetIsCached(DependencyObject obj)
    {
        return (bool)obj.GetValue(IsCachedProperty);
    }

    public static void SetIsCached(DependencyObject obj, bool value)
    {
        obj.SetValue(IsCachedProperty, value);
    }

    /// <summary>
    /// Controls whether tab content is cached or not
    /// </summary>
    /// <remarks>When TabContent.IsCached is true, visual state of each tab is preserved (cached), even when the tab is hidden</remarks>
    public static readonly DependencyProperty IsCachedProperty =
        DependencyProperty.RegisterAttached("IsCached", typeof(bool), typeof(TabContent), new UIPropertyMetadata(false, OnIsCachedChanged));


    public static DataTemplate GetTemplate(DependencyObject obj)
    {
        return (DataTemplate)obj.GetValue(TemplateProperty);
    }

    public static void SetTemplate(DependencyObject obj, DataTemplate value)
    {
        obj.SetValue(TemplateProperty, value);
    }

    /// <summary>
    /// Used instead of TabControl.ContentTemplate for cached tabs
    /// </summary>
    public static readonly DependencyProperty TemplateProperty =
        DependencyProperty.RegisterAttached("Template", typeof(DataTemplate), typeof(TabContent), new UIPropertyMetadata(null));


    public static DataTemplateSelector GetTemplateSelector(DependencyObject obj)
    {
        return (DataTemplateSelector)obj.GetValue(TemplateSelectorProperty);
    }

    public static void SetTemplateSelector(DependencyObject obj, DataTemplateSelector value)
    {
        obj.SetValue(TemplateSelectorProperty, value);
    }

    /// <summary>
    /// Used instead of TabControl.ContentTemplateSelector for cached tabs
    /// </summary>
    public static readonly DependencyProperty TemplateSelectorProperty =
        DependencyProperty.RegisterAttached("TemplateSelector", typeof(DataTemplateSelector), typeof(TabContent), new UIPropertyMetadata(null));

    [EditorBrowsable(EditorBrowsableState.Never)]
    public static TabControl GetInternalTabControl(DependencyObject obj)
    {
        return (TabControl)obj.GetValue(InternalTabControlProperty);
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public static void SetInternalTabControl(DependencyObject obj, TabControl value)
    {
        obj.SetValue(InternalTabControlProperty, value);
    }

    // Using a DependencyProperty as the backing store for InternalTabControl.  This enables animation, styling, binding, etc...
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static readonly DependencyProperty InternalTabControlProperty =
        DependencyProperty.RegisterAttached("InternalTabControl", typeof(TabControl), typeof(TabContent), new UIPropertyMetadata(null, OnInternalTabControlChanged));


    [EditorBrowsable(EditorBrowsableState.Never)]
    public static ContentControl GetInternalCachedContent(DependencyObject obj)
    {
        return (ContentControl)obj.GetValue(InternalCachedContentProperty);
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public static void SetInternalCachedContent(DependencyObject obj, ContentControl value)
    {
        obj.SetValue(InternalCachedContentProperty, value);
    }

    // Using a DependencyProperty as the backing store for InternalCachedContent.  This enables animation, styling, binding, etc...
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static readonly DependencyProperty InternalCachedContentProperty =
        DependencyProperty.RegisterAttached("InternalCachedContent", typeof(ContentControl), typeof(TabContent), new UIPropertyMetadata(null));

    [EditorBrowsable(EditorBrowsableState.Never)]
    public static object GetInternalContentManager(DependencyObject obj)
    {
        return (object)obj.GetValue(InternalContentManagerProperty);
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public static void SetInternalContentManager(DependencyObject obj, object value)
    {
        obj.SetValue(InternalContentManagerProperty, value);
    }

    // Using a DependencyProperty as the backing store for InternalContentManager.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty InternalContentManagerProperty =
        DependencyProperty.RegisterAttached("InternalContentManager", typeof(object), typeof(TabContent), new UIPropertyMetadata(null));

    private static void OnIsCachedChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
    {
        if (obj == null) return;

        var tabControl = obj as TabControl;
        if (tabControl == null)
        {
            throw new InvalidOperationException("Cannot set TabContent.IsCached on object of type " + args.NewValue.GetType().Name +
                ". Only objects of type TabControl can have TabContent.IsCached property.");
        }

        bool newValue = (bool)args.NewValue;

        if (!newValue)
        {
            if (args.OldValue != null && ((bool)args.OldValue))
            {
                throw new NotImplementedException("Cannot change TabContent.IsCached from True to False. Turning tab caching off is not implemented");
            }

            return;
        }

        EnsureContentTemplateIsNull(tabControl);
        tabControl.ContentTemplate = CreateContentTemplate();
    }

    private static DataTemplate CreateContentTemplate()
    {
        const string xaml =
            "<DataTemplate><Border b:TabContent.InternalTabControl=\"{Binding RelativeSource={RelativeSource AncestorType=TabControl}}\" /></DataTemplate>";

        var context = new ParserContext();

        context.XamlTypeMapper = new XamlTypeMapper(new string[0]);
        context.XamlTypeMapper.AddMappingProcessingInstruction("b", typeof(TabContent).Namespace, typeof(TabContent).Assembly.FullName);

        context.XmlnsDictionary.Add("", "http://schemas.microsoft.com/winfx/2006/xaml/presentation");
        context.XmlnsDictionary.Add("b", "b");

        var template = (DataTemplate)XamlReader.Parse(xaml, context);
        return template;
    }

    private static void OnInternalTabControlChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
    {
        if (obj == null) return;
        var container = obj as Decorator;

        if (container == null)
        {
            var message = "Cannot set TabContent.InternalTabControl on object of type " + obj.GetType().Name +
                ". Only controls that derive from Decorator, such as Border can have a TabContent.InternalTabControl.";
            throw new InvalidOperationException(message);
        }

        if (args.NewValue == null) return;
        if (!(args.NewValue is TabControl))
        {
            throw new InvalidOperationException("Value of TabContent.InternalTabControl cannot be of type " + args.NewValue.GetType().Name + ", it must be of type TabControl");
        }

        var tabControl = (TabControl)args.NewValue;
        var contentManager = GetContentManager(tabControl, container);
        contentManager.UpdateSelectedTab();
    }

    private static ContentManager GetContentManager(TabControl tabControl, Decorator container)
    {
        var contentManager = (ContentManager)GetInternalContentManager(tabControl);
        if (contentManager != null)
        {
            /*
             * Content manager already exists for the tab control. This means that tab content template is applied 
             * again, and new instance of the Border control (container) has been created. The old container 
             * referenced by the content manager is no longer visible and needs to be replaced
             */
            contentManager.ReplaceContainer(container);
        }
        else
        {
            // create content manager for the first time
            contentManager = new ContentManager(tabControl, container);
            SetInternalContentManager(tabControl, contentManager);
        }

        return contentManager;
    }

    private static void EnsureContentTemplateIsNull(TabControl tabControl)
    {
        if (tabControl.ContentTemplate != null)
        {
            throw new InvalidOperationException("TabControl.ContentTemplate value is not null. If TabContent.IsCached is True, use TabContent.Template instead of ContentTemplate");
        }
    }

    public class ContentManager
    {
        TabControl _tabControl;
        Decorator _border;

        public ContentManager(TabControl tabControl, Decorator border)
        {
            _tabControl = tabControl;
            _border = border;
            _tabControl.SelectionChanged += (sender, args) => { UpdateSelectedTab(); };
        }

        public void ReplaceContainer(Decorator newBorder)
        {
            if (Object.ReferenceEquals(_border, newBorder)) return;

            _border.Child = null; // detach any tab content that old border may hold
            _border = newBorder;
        }

        public void UpdateSelectedTab()
        {
            _border.Child = GetCurrentContent();
        }

        private ContentControl GetCurrentContent()
        {
            var item = _tabControl.SelectedItem;
            if (item == null) return null;

            var tabItem = _tabControl.ItemContainerGenerator.ContainerFromItem(item);
            if (tabItem == null) return null;

            var cachedContent = TabContent.GetInternalCachedContent(tabItem);
            if (cachedContent == null)
            {
                cachedContent = new ContentControl
                {
                    DataContext = item,
                    ContentTemplate = TabContent.GetTemplate(_tabControl),
                    ContentTemplateSelector = TabContent.GetTemplateSelector(_tabControl)
                };

                cachedContent.SetBinding(ContentControl.ContentProperty, new Binding());
                TabContent.SetInternalCachedContent(tabItem, cachedContent);
            }

            return cachedContent;
        }
    }
}

VladD · Answer 2 · 2020-07-26T06:59:32Z

关键是它TabControl试图对所有选项卡的内容使用相同的控件。在这方面，视觉状态当然是丢失了。

我这样为自己解决了这个问题：

我TabControl删除了内容，只留下标签。
由于标准TabControl留有空间，我不得不在底部添加一个负边距。
在TabControl'om located下Grid，其中存储了选项卡内容的所有视图，通过切换执行所需的显示Visibility。为了避免手动操作，我使用了标准~~ItemsControl的“om~~ ListBox ”技巧。

这是完整的代码：

<Window x:Class="Test.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Тест" Height="350" Width="525">
    <Window.Resources>
        <BooleanToVisibilityConverter x:Key="B2V"/>
    </Window.Resources>
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <Border ClipToBounds="True" Grid.Row="0">
            <TabControl ItemsSource="{Binding}" DisplayMemberPath="Header"
                        Margin="0,0,0,-5" x:Name="TabControlAbove">
                <TabControl.ContentTemplate>
                    <DataTemplate/>
                </TabControl.ContentTemplate>
            </TabControl>
        </Border>
        <ListBox ItemsSource="{Binding}" Grid.Row="1" BorderThickness="0"
                 SelectedItem="{Binding SelectedItem, ElementName=TabControlAbove}">
            <ListBox.ItemContainerStyle>
                <Style TargetType="ListBoxItem">
                    <Setter Property="Template">
                        <Setter.Value>
                            <ControlTemplate TargetType="ListBoxItem">
                                <ContentPresenter/>
                            </ControlTemplate>
                        </Setter.Value>
                    </Setter>
                    <Setter
                        Property="Visibility"
                        Value="{Binding IsSelected, RelativeSource={RelativeSource Self},
                                   Converter={StaticResource B2V}}"/>
                </Style>
            </ListBox.ItemContainerStyle>
            <ListBox.ItemsPanel>
                <ItemsPanelTemplate>
                    <Grid/>
                </ItemsPanelTemplate>
            </ListBox.ItemsPanel>
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <TextBlock Text="{Binding Content}"/>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
    </Grid>
</Window>

虚拟机类：

class VM { }
class VM1 : VM
{
    public string Header { get { Debug.Print("VM1.Header.get"); return "Что-то"; } }
    public string Content { get { Debug.Print("VM1.Content.get");
                                  return "В лесу родилась ёлочка"; } }
}
class VM2 : VM
{
    public string Header { get { Debug.Print("VM2.Header.get"); return "Кто-то"; } }
    public string Content { get { Debug.Print("VM2.Content.get");
                                  return "И Гена-крокодил"; } }
}

DataContext:

new VM[]
{
    new VM1(),
    new VM2()
}

结果：

在这种情况下，吸气剂只工作一次，这可以在日志中看到。

tretetex · Answer 3 · 2020-10-23T18:59:52Z

除了@VladD的回答。

Чтобы при старте приложения первая вкладка по умолчанию была выбрана, в MainWindow делаем установку Loaded += (s, e) => TabControlAbove.SelectedIndex = 0;.
Также нужно обработать Ctrl+Click по содержимому вкладки, иначе будет срабатывать снятие выделения с текущего ListBoxItem и содержимое пропадет. Для этого вешаем на ListBox обработчик SelectionChanged="ListBox_SelectionChanged", в котором проверяем, что добавляемый элемент есть:

private bool cancellingTabSelectionChange;
private void ListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
    if (e.AddedItems.Count == 0 && !cancellingTabSelectionChange)
    {
        cancellingTabSelectionChange = true;
        ((ListBox)sender).SelectedItem = e.RemovedItems[0];
        cancellingTabSelectionChange = false;
    }
}

在 TabControl 中更改活动选项卡时重置 DataTemplate 中的属性

Python 3.6 - 安装 MySQL (Windows)

C++ 编写程序“计算单个岛屿”。填充一个二维数组 12x12 0 和 1

返回指针的函数

我使用 django 管理面板添加图像，但它没有显示

这些条目是什么意思，它们的完整等效项是什么样的

浏览器仍然缓存文件数据

在 Excel VBA 中激活工作表的问题

为什么内置类型中包含复数而小数不包含？

获得唯一途径

告诉我一个像幻灯片一样创建滚动的库

在 TabControl 中更改活动选项卡时重置 DataTemplate 中的属性

3 个回答

相关问题