TreeView Expanden zum vorher definierten Item

  • WPF

Es gibt 4 Antworten in diesem Thema. Der letzte Beitrag () ist von Nofear23m.

    TreeView Expanden zum vorher definierten Item

    Hi,
    ich hab gerade ein Problemchen bei dem ich mir, selbst nach einiger Zeit googlen, die Zähne ausbeiße.
    Ich hab ein TreeView welches mir alle Unterordner und Dateien in einem vorgegeben Pfad auflistet, soweit so gut.
    Bei Klick auf eine Datei wird diese in einem TabPage geöffnet, passt auch.
    Nun hab ich in den Settings ein Propertie LastOpenFile im MainViewModel weise ich dem SelectedItem den Pfad aus LastOpenFile zu und öffne die Datei im entsprechenden TabPage (siehe ReloadDate() ab Zeile 194.
    Das funktioniert alles bestens, doch wie kann ich nun dem TreeView verklickern, das es bis zu diesem Selected Item expanden soll? (die IsSelected und IsExpanden Properties sind im DirectoryItemViewModel.

    Ich nutze folgende ViewModels:
    Das MainViewModel mit dem Selected Item:
    MainViewModel

    C#-Quellcode

    1. public class MainViewModel : ViewModelBase
    2. {
    4. #region Private Properties
    6. private string _path => IoC.Application.CodeFolderPath;
    8. #endregion
    10. #region Constructor
    12. public MainViewModel()
    13. {
    14. if (!string.IsNullOrEmpty(_path))
    15. {
    16. ReloadData();
    17. ClearTabPages();
    18. InitCommands();
    20. }
    22. }
    24. #endregion
    26. #region Public Properties
    28. public ObservableCollection<DirectoryItemViewModel> DirectoryItems { get; set; }
    29. public DirectoryItemViewModel SelectedItem { get; set; }
    31. public ObservableCollection<TabPageViewModel> TabPages { get; set; }
    32. public TabPageViewModel SelectedTab { get; set; }
    34. public string RootFolderName => _path.GetFileFolderName();
    36. public bool CanCloseAllTabPages => TabPages.Count > 0;
    38. public bool CanAddNewFileOrFolder => SelectedItem != null && SelectedItem.Type == DirectoryItemTypeEnum.Folder;
    40. public bool CanSave => FileFolderName.Length > 0;
    42. public bool HasItems => DirectoryItems.Count > 0;
    44. public bool OnCreate { get; set; }
    46. public string TextEntryLabel { get; set; }
    48. public string FileFolderName { get; set; } = string.Empty;
    50. #endregion
    52. #region Events
    54. private void DirectoryItems_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
    55. {
    57. OnPropertyChanged(nameof(CanAddNewFileOrFolder));
    58. OnPropertyChanged(nameof(HasItems));
    59. }
    60. private void TabPages_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
    61. {
    62. OnPropertyChanged(nameof(CanCloseAllTabPages));
    63. }
    65. #endregion
    67. #region Commands
    69. public ICommand OpenFileCommand { get; set; }
    71. public ICommand CloseTabCommand { get; set; }
    73. public ICommand CloseAllTabsCommand { get; set; }
    75. public ICommand AddNewFileCommand { get; set; }
    77. public ICommand AddNewFolderCommand { get; set; }
    79. public ICommand ExpandAndCollapsAllCommand { get; set; }
    81. public ICommand OpenRootFolderCommand { get; set; }
    83. public ICommand SaveFileOrFolderCommand { get; set; }
    85. public ICommand CancelFileOrFolderCommand { get; set; }
    87. #endregion
    89. #region Comamnd Methods
    90. private void OpenFile(object param)
    91. {
    92. SelectedItem = param as DirectoryItemViewModel;
    93. if (SelectedItem.Type != DirectoryItemTypeEnum.File) return;
    94. TabPageViewModel existingTab = TabPages.Where(x => x.Tag == SelectedItem.FullPath).FirstOrDefault();
    95. if (existingTab != null)
    96. SelectedTab = existingTab;
    97. else
    98. {
    99. var newTab = new TabPageViewModel(SelectedItem.Name, SelectedItem.FullPath,
    100. new EditorViewModel (SelectedItem.FullPath));
    101. TabPages.Add(newTab);
    102. SelectedTab = newTab;
    103. }
    104. SelectedItem.IsSelected = true;
    105. }
    107. private void CloseTab(object param)
    108. {
    109. var tabToClose = param as TabPageViewModel;
    110. if(tabToClose.Editor.IsModified)
    111. {
    112. //TODO: Über IoC MessageBox aufrufen und dort das Speichern abfragen
    113. DirectoryStructure.SaveContent(tabToClose.Tag, tabToClose.Editor.Content);
    115. }
    116. TabPages.Remove(tabToClose);
    117. if (TabPages.Count <= 0)
    118. ClearTabPages();
    119. }
    121. private void AddNewFileOrFolder(string arg)
    122. {
    123. if (SelectedItem != null && SelectedItem.Type == DirectoryItemTypeEnum.Folder)
    124. {
    125. if (arg == "Neue Datei")
    126. {
    127. var newFile = new DirectoryItemViewModel(SelectedItem.FullPath + @"\" + FileFolderName, DirectoryItemTypeEnum.File);
    128. SelectedItem.ChildItems.Add(newFile);
    129. var newTab = new TabPageViewModel(newFile.Name, newFile.FullPath,
    130. new EditorViewModel("Code goes here", newFile.FullPath) { IsModified = true });
    131. DirectoryStructure.SaveContent(newTab.Tag, newTab.Editor.Content);
    132. TabPages.Add(newTab);
    133. SelectedTab = newTab;
    134. }
    135. else
    136. {
    137. DirectoryStructure.CreateDirectories(SelectedItem.FullPath + @"\" + FileFolderName);
    138. ReloadData();
    139. }
    140. }
    141. FileFolderName = string.Empty;
    142. OnCreate = false;
    144. }
    146. private void CloseAllTabPages()
    147. {
    148. if(TabPages.Any(t => t.Editor.IsModified))
    149. {
    150. //TODO: Messagebox zum speichern
    152. }
    153. ClearTabPages();
    154. }
    156. private void ExpandAndCollapsAll()
    157. {
    158. foreach (var item in DirectoryItems)
    159. {
    160. if (item.Type == DirectoryItemTypeEnum.Folder)
    161. item.IsExpanded ^= true;
    162. }
    163. }
    165. public void OpenRootFolder()
    166. {
    167. //TODO: FolderBrowserDialog aufrufen
    168. CloseAllTabPages();
    169. ReloadData();
    170. OnPropertyChanged(nameof(RootFolderName));
    171. }
    173. private void Edit(string label)
    174. {
    175. TextEntryLabel = label;
    176. OnCreate = true;
    177. }
    179. private void Cancel()
    180. {
    181. FileFolderName = string.Empty;
    182. OnCreate = false;
    183. }
    184. #endregion
    186. #region Helper Methods
    188. private void ClearTabPages()
    189. {
    190. TabPages = new ObservableCollection<TabPageViewModel>();
    191. TabPages.CollectionChanged += TabPages_CollectionChanged;
    192. }
    194. private void ReloadData()
    195. {
    196. DirectoryItems = new ObservableCollection<DirectoryItemViewModel>(_path.GetFilesFolders().Select(f => new DirectoryItemViewModel(f.FullPath, f.Type)));
    197. DirectoryItems.CollectionChanged += DirectoryItems_CollectionChanged;
    198. SelectedItem = new DirectoryItemViewModel(IoC.Settings.LastOpenFile, DirectoryItemTypeEnum.File);
    200. SelectedItem.IsSelected = true;
    201. SelectedTab = new TabPageViewModel(SelectedItem.Name, SelectedItem.FullPath, new EditorViewModel(SelectedItem.FullPath));
    202. TabPages.Add(SelectedTab);
    204. }
    206. private void InitCommands()
    207. {
    208. OpenFileCommand = new RelayCommand(o => OpenFile(o));
    209. CloseTabCommand = new RelayCommand(c => CloseTab(c));
    210. CloseAllTabsCommand = new RelayCommand(c => CloseAllTabPages()).ObservesCanExecute(() => CanCloseAllTabPages);
    211. AddNewFileCommand = new RelayCommand(a => Edit("Neue Datei")).ObservesCanExecute(() => CanAddNewFileOrFolder);
    212. AddNewFolderCommand = new RelayCommand(a => Edit("Neuer Ordner")).ObservesCanExecute(() => CanAddNewFileOrFolder);
    213. ExpandAndCollapsAllCommand = new RelayCommand(e => ExpandAndCollapsAll());
    214. OpenRootFolderCommand = new RelayCommand(o => OpenRootFolder());
    215. SaveFileOrFolderCommand = new RelayCommand(s => AddNewFileOrFolder(TextEntryLabel)).ObservesCanExecute(() => CanSave);
    216. CancelFileOrFolderCommand = new RelayCommand(c =>Cancel());
    217. }
    219. #endregion
    220. }



    Das DirectoryItemViewModel für ein einzelnes Item:
    DirectoryItemViewModel

    C#-Quellcode

    1. public class DirectoryItemViewModel : ViewModelBase
    2. {
    3. #region Constructor
    5. /// <summary>
    6. /// default constructor
    7. /// </summary>
    8. public DirectoryItemViewModel()
    9. {
    11. }
    13. public DirectoryItemViewModel(string fullpath, DirectoryItemTypeEnum type)
    14. {
    15. FullPath = fullpath;
    16. Type = type;
    17. ClearDirectoryItems();
    18. InitCommands();
    19. }
    21. #endregion
    23. #region Public Properties
    25. #region Model Properties
    27. public string FullPath { get; set; }
    29. public string Name => Type == DirectoryItemTypeEnum.Drive ? FullPath : FullPath.GetFileFolderName();
    31. public DirectoryItemTypeEnum Type { get; set; }
    33. #endregion
    35. #region UI Properties
    37. public string ImageName => Type == DirectoryItemTypeEnum.Drive ? "drive" : (Type == DirectoryItemTypeEnum.File ? "file" : (IsExpanded ? "folder-open" : "folder-close"));
    39. public ObservableCollection<DirectoryItemViewModel> ChildItems { get; set; }
    41. public bool CanOpen => Type == DirectoryItemTypeEnum.File;
    43. public bool CanExpand => Type != DirectoryItemTypeEnum.File;
    45. public bool IsSelected { get; set; }
    47. public bool IsExpanded
    48. {
    49. get => ChildItems?.Count(i => i != null) > 0;
    50. set
    51. {
    52. if (value == true)
    53. Expand();
    54. else
    55. ClearDirectoryItems();
    56. }
    57. }
    58. #endregion
    60. #endregion
    62. #region Commands
    64. public ICommand ExpandCommand { get; set; }
    66. #endregion
    68. #region Command Methods
    69. private void Expand()
    70. {
    71. if (Type == DirectoryItemTypeEnum.File)
    72. return;
    74. ChildItems = new ObservableCollection<DirectoryItemViewModel>(FullPath.GetFilesFolders().Select(item => new DirectoryItemViewModel(item.FullPath, item.Type)));
    75. }
    77. #endregion
    79. #region Helper Methods
    81. private void InitCommands()
    82. {
    83. ExpandCommand = new RelayCommand(e => Expand());
    84. }
    86. private void ClearDirectoryItems()
    87. {
    88. ChildItems = new ObservableCollection<DirectoryItemViewModel>();
    89. if (Type != DirectoryItemTypeEnum.File)
    90. ChildItems.Add(null);
    92. }
    94. #endregion
    95. }



    dann nmoch die entsprechende Stelle im TreeView:
    TreeView Xaml

    XML-Quellcode

    1. <!-- #region TreeView (Row 1) -->
    3. <TreeView x:Name="tv" ItemsSource="{Binding DirectoryItems}" Grid.Row="2" BorderThickness="0" Background="{StaticResource BackgroundVeryLightBrush}">
    4. <TreeView.Resources>
    5. <LinearGradientBrush x:Key="{x:Static SystemColors.HighlightBrushKey}" EndPoint="0,1" StartPoint="0,0">
    6. <GradientStop Color="{StaticResource DefaultLightDark}" Offset="0"/>
    7. <GradientStop Color="{StaticResource DefaultLight}" Offset="1"/>
    8. </LinearGradientBrush>
    9. <LinearGradientBrush x:Key="{x:Static SystemColors.ControlBrushKey}" EndPoint="0,1" StartPoint="0,0">
    10. <GradientStop Color="#FFF8F8F8" Offset="0"/>
    11. <GradientStop Color="#FFE5E5E5" Offset="1"/>
    12. </LinearGradientBrush>
    13. <SolidColorBrush x:Key="{x:Static SystemColors.HighlightTextBrushKey}" Color="Black" />
    14. <SolidColorBrush x:Key="{x:Static SystemColors.ControlTextBrushKey}" Color="Black" />
    15. </TreeView.Resources>
    17. <TreeView.ItemContainerStyle>
    18. <Style TargetType="{x:Type TreeViewItem}">
    19. <Setter Property="IsExpanded" Value="{Binding IsExpanded, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"/>
    20. <Setter Property="IsSelected" Value="{Binding IsSelected, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"/>
    21. <Style.Triggers>
    22. <Trigger Property="IsSelected" Value="True">
    23. <Setter Property="Background" Value="{StaticResource BackgroundGradientBrush}"/>
    24. </Trigger>
    25. <Trigger Property="IsMouseOver" Value="True">
    26. <Setter Property="Background" Value="{StaticResource BackgroundGradientBrush}"/>
    27. </Trigger>
    28. </Style.Triggers>
    29. <Style.Resources>
    30. <Style TargetType="{x:Type Border}">
    31. <Setter Property="CornerRadius" Value="2"/>
    32. </Style>
    33. </Style.Resources>
    34. </Style>
    35. </TreeView.ItemContainerStyle>
    36. <TreeView.ItemTemplate>
    37. <HierarchicalDataTemplate ItemsSource="{Binding ChildItems}">
    38. <StackPanel Orientation="Horizontal" Margin="5 0 10 0">
    39. <Image Width="20" Margin="3" Source="{Binding ImageName, Converter={local:HeaderTextToImageConverter}}"/>
    40. <TextBlock Text="{Binding Name, UpdateSourceTrigger=LostFocus}"
    41. VerticalAlignment="Center"
    42. Foreground="{StaticResource CharDarkBlueBrush}"
    43. FontSize="{StaticResource FontSizeRegular}"
    44. Background="Transparent"
    45. Padding="2" >
    46. <TextBlock.InputBindings>
    47. <MouseBinding MouseAction="LeftClick" Command="{Binding DataContext.OpenFileCommand, ElementName=mainUc}" CommandParameter="{Binding}"/>
    48. </TextBlock.InputBindings>
    49. </TextBlock>
    51. </StackPanel>
    52. </HierarchicalDataTemplate>
    53. </TreeView.ItemTemplate>
    54. </TreeView>
    55. <!-- #endregion -->



    Nicht wundern in den ViewModels, ich nutze hier noch das nuget Packet Fody, das bin ich gerade am Ändern.

    Was ich bisher gelesen habe, sollte das TreeView selbst expanden, wenn IsSelected gesetzt wird.
    Die Lösungen im Netz sind entweder CodeBehind, Behaiviors, oder Dependency Properties.
    Aber das müsste doch in WPF einfacher gehen, oder?

    Danke Euch
    "Hier könnte Ihre Werbung stehen..."

    Update:
    ich bin nun soweit gekommen, das ich im TreeView den SelectedValuePath auf SelectedItem gebunden habe

    das richtige Item wird dadurch selected (siehe Screenshot 1).
    es wird aber nicht expanded bis dahin (siehe ScreenShot 2).

    expande ich selber bis zum entsprechenden Item, sieht man das es selektiert ist.

    Änderunge die ich gemacht habe sind:

    im MainViewModel:

    C#-Quellcode

    1. public MainViewModel()
    2. {
    3. if (!string.IsNullOrEmpty(_path))
    4. {
    5. ReloadData();
    6. ClearTabPages();
    7. InitCommands();
    8. SelectedItem = new DirectoryItemViewModel(IoC.Settings.LastOpenFile, DirectoryItemTypeEnum.File);
    9. SelectedTab = new TabPageViewModel(SelectedItem.Name, SelectedItem.FullPath, new EditorViewModel(SelectedItem.FullPath));
    10. TabPages.Add(SelectedTab);
    11. }
    13. }


    und im TreeView:

    XML-Quellcode

    1. <TreeView x:Name="tv" ItemsSource="{Binding DirectoryItems}" SelectedValuePath="{Binding SelectedItem}" Grid.Row="2" BorderThickness="0" Background="{StaticResource BackgroundVeryLightBrush}">
    "Hier könnte Ihre Werbung stehen..."

    Hallo Micha

    Das problem besteht darin das du ja nicht einfach alle Ordner und dessen Childs durchlaufen und als Selected oder Expanded markieren kannst da es diese ja (noch) nicht gibt.
    Denn ich nehme an du befüllst die Childs erst beim "Expanden". Also LazyLoading. (vermute ich zumindest)

    Du musst also zusehen das du immer genau den Knoten der obersten Eben findest -> diesen Aufklappst damit die Unterodner geladen werden -> dann in diesen den nächsten "Level" suchen.

    Ich habe mal ein Demo gemacht.

    MichaHo schrieb:

    ich nutze hier noch das nuget Packet Fody, das bin ich gerade am Ändern

    Warum das plötzlich wenn ich Fragen darf.
    Wenn ich raten würde dann ist es weil es mit diesem System vermutlich keinen DesignTimeSupport gibt oder? Oder klappt das auch?

    Grüße
    Sascha
    Dateien
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.

    ## Bitte markiere einen Thread als "Erledigt" wenn deine Frage beantwortet wurde. ##

    Hi Sascha,
    Danke Dir, schaue ich mir an.
    design time war ein Grund. Der 2. Grund ist, das man sehr schnell vergisst wo eigentlich überall benachrichtigt werden muss. Mit der Lösung die ich jetzt habe ist es nicht viel mehr Code, aber ich sehe auf Anhieb wo ich vergessen habe eine Benachrichtigung einzubauen...
    genauso wie mit den Icons, das war schon ne schöne Sache mit der Schriftart, aber es fehlten einige Icons darin die ich benötige und nun hab ich alle Icons und die Buttons verhalten sich genauso wie vorher...
    So langsam werde ich mit WPF echt warm... mein SnipsCode ist fast fertig und das nächste Projekt, diesmal beruflich, steht kurz vorm Beginn.
    "Hier könnte Ihre Werbung stehen..."

    MichaHo schrieb:

    So langsam werde ich mit WPF echt warm

    Das freut mich. Man sieht bei dir auch die Entwicklung weil du eben dran bleibst. Ich weis das es für viele sehr schwer ist die WPF zu verstehen aber wenn man bedenkt was die WPF alles kann und wie mächtig Binding ist finde ich ist die WPF dann gar nicht sooo kompliziert. Anders, ja - aber nicht komplizierter.

    Schöne Grüße
    Sascha
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.

    ## Bitte markiere einen Thread als "Erledigt" wenn deine Frage beantwortet wurde. ##

Facebook
Telefonspende