My Personal Commander Variant

// This file is part of the Lobster.MPCV application
// Copyright: Andreas Raczek
// This file is published under the The Code Project Open License (CPOL) 
// See the file "CPOL.html" for the full license governing this code.

using System;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Linq;
using System.Windows.Data;
using System.Windows.Input;
using System.Xml.Serialization;
using Lobster.Components.Collections.Joiner;
using Lobster.MVVM;

namespace Lobster.MPCV.VM
{
    /// <summary>
    /// Represents the contents of a tabsheet in the main window
    /// </summary>
    public class FolderBrowserGridVM : Lobster.MVVM.UIElementVM
    {
        public FolderBrowserGridVM() :
            this("Loaded Tab")
        {
        }

        public FolderBrowserGridVM(string tabName) :
            base(tabName)
        {
#if OLDGRIDPROPERTYMODE
            AddRow = new Lobster.MVVM.DelegateCommand(
                (o) => _AddRow());
            
            RemoveRow = new Lobster.MVVM.DelegateCommand(
                (o) => _RemoveRow(), 
                (o) => folderSets.Count > 1);

            AddBrowser = new Lobster.MVVM.DelegateCommand(
                (o) => _AddBrowser());

            RemoveBrowser = new Lobster.MVVM.DelegateCommand(
                (o) => _RemoveBrowser(),
                (o) => _CanRemoveBrowser());

            EndPropertyMode = new DelegateCommand(
                (o) => { 
                    PropertyMode = false;
                    });
#endif
            folderBrowserJoiner.CreateItemBox = (item) =>
            {
                return new FolderBrowserInfoVM(this, item);
            };

            folderSets.CollectionChanged += folderSets_CollectionChanged;

            CloseTab = new DelegateCommand(
                (o) => OnRequestClose(), 
                (o) => DisplayName != "+");            

            toolbarCommands = new ObservableCollection<UICommandVM>();

            toolbarViewSource = new CollectionViewSource();
            toolbarViewSource.Source = toolbarCommands;
            toolbarViewSource.Filter += (object sender, FilterEventArgs e) => 
            {
                var i = (UICommandVM) e.Item;
                e.Accepted = i.Command.Length > 0;
            };
            toolbarCommands.CollectionChanged += (o, e) =>
            {
                UpdateToolbar();

                if (e.NewItems != null)
                {
                    foreach (var i in e.NewItems)
                    {
                        var tbc = (UICommandVM)i;
                        tbc.PropertyChanged += (io, ie) =>
                        {
                            UpdateToolbar();
                        };
                    }
                }
            };

            EndEditing = false;

            TokenReplacer = new Util.CommandTokenReplacer(this);
        }

        public FolderBrowserSetVM AddRow()
        {
            var psvm = new FolderBrowserSetVM();
            folderSets.Add(psvm);
            psvm.InitNew();
            return psvm;
        }

#if OLDGRIDPROPERTYMODE
        private void _RemoveRow()
        {
            if (folderSets.Count > 0)
            {
                var toRemove = folderSets[folderSets.Count - 1];
                folderSets.Remove(toRemove);
            }
        }

        private bool _CanRemoveBrowser() 
        {
            var toDel = SelectedFolderBrowserInfo;
            if (toDel == null) return false;

            return FolderSets[toDel.Y].Items.Count > 1;
        }

        private void _RemoveBrowser()
        {
            var toDel = SelectedFolderBrowserInfo;
            if (toDel == null) return;

            FolderSets[toDel.Y].Items.RemoveAt(toDel.X);
        }

        private void _AddBrowser()
        {
            var toAdd = SelectedFolderBrowserInfo;
            if (toAdd == null) return;

            FolderSets[toAdd.Y].Items.Insert(
                toAdd.X + 1,
                new FolderBrowserVM()); 
        }
#endif

        void folderSets_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            if (e.OldItems != null) {
                foreach (var i in e.OldItems)
                {
                    var oci = (FolderBrowserSetVM) i;
                    folderBrowserJoiner.Collections.Remove(oci.Items);
                }
            }

            if (e.NewItems != null) {
                foreach (var i in e.NewItems) 
                {
                    var oci = (FolderBrowserSetVM)i;
                    folderBrowserJoiner.Collections.Add(oci.Items);
                }
            }
        }

        public void InitNew() 
        {
            for (int i=0; i<2; i++) 
            {
                AddRow();
            }
        }

        private ObservableCollection<FolderBrowserSetVM> folderSets = new ObservableCollection<FolderBrowserSetVM>();

        [XmlArrayItem(typeof(FolderBrowserSetVM))]
        [XmlArray]        
        public ObservableCollection<FolderBrowserSetVM> FolderSets
        {
            get
            {
                return folderSets;
            }
        }

#if OLDGRIDPROPERYMODE
        [XmlIgnore]
        public ICommand AddRow { get; private set; }

        [XmlIgnore]
        public ICommand RemoveRow { get; private set; }

        [XmlIgnore]
        public ICommand AddBrowser { get; private set; }

        [XmlIgnore]
        public ICommand RemoveBrowser { get; private set; }

        [XmlIgnore]
        public ICommand EndPropertyMode { get; private set; }

        private bool propertyMode = false;

        [XmlIgnore]
        public bool PropertyMode { 
            get { return propertyMode; }
            set {
                if (value != propertyMode) {
                    propertyMode = value;

                    if (propertyMode == false) {                        
                        UpdateToolbar();
                    }

                    OnPropertyChanged("PropertyMode");
                }
            }
        }
#endif
        [XmlIgnore]
        public ICommand CloseTab { get; private set; }

        private void UpdateToolbar() 
        {
            // Stop listening to execute events, as we are not sure if they are still 
            // present after the refresh ...
            foreach (var i in EnabledToolbarCommands)
            {
                var tbc = (UICommandVM)i;
                // tbc.ReplaceTokens = null;
                tbc.TokenReplacer = null;
            }

            // Make the toolbar view source reflect the changes done to it
            toolbarViewSource.View.Refresh();

            // Listen to execute events
            foreach (var i in EnabledToolbarCommands) 
            {
                var tbc = (UICommandVM) i;
                // tbc.ReplaceTokens = Toolbar_ReplaceCommandTokens;
                tbc.TokenReplacer = this.TokenReplacer;
            }
        }

        [XmlIgnore]
        public Util.CommandTokenReplacer TokenReplacer
        {
            get;
            private set;
        }

#if OLDGRIDPROPERTYMODE
        /// <summary>
        /// Used by DataGrid in old Property Panel
        /// </summary>
        [XmlIgnore]
        public IItemBox<FolderBrowserVM> SelectedFolderBrowserInfo 
        {
            get; set;
        }
#endif

        [XmlIgnore]
        private ObservableCollectionJoiner<FolderBrowserVM> folderBrowserJoiner = new ObservableCollectionJoiner<FolderBrowserVM>();

        /// <summary>
        /// Lists all folderbrowsers in the grid for linear display. The ItemBox also
        /// adds functionality for acquiring the index of items in the collection.
        /// </summary>
        [XmlIgnore]
        public ReadOnlyObservableCollection<ItemBox<FolderBrowserVM>> FolderBrowserInfo 
        {
            get {
                return folderBrowserJoiner.JoinedCollection;
            }
        }

        #region RequestClose [event]

        /// <summary>
        /// Raised when this workspace should be removed from the UI.
        /// </summary>
        public event EventHandler RequestClose;

        void OnRequestClose()
        {
            EventHandler handler = this.RequestClose;
            if (handler != null)
                handler(this, EventArgs.Empty);
        }

        #endregion // RequestClose [event]

        /// <summary>
        /// Performs post-XML-Loading operation. Not all information
        /// is serialized via ctor and XML, information depending on
        /// the deserialized XML is generated afterwards.
        /// </summary>
        internal void OnLoaded()
        {
            foreach (var fbi in FolderBrowserInfo) 
            {
                ((FolderBrowserInfoVM) fbi).OnLoaded();
            }

            UpdateToolbar();
        }

        private ObservableCollection<UICommandVM> toolbarCommands;
        public ObservableCollection<UICommandVM> ToolbarCommands {
            get {
                return toolbarCommands;
            }
        }

        [XmlIgnore]
        private CollectionViewSource toolbarViewSource;
        public ICollectionView EnabledToolbarCommands {
            get {
                return toolbarViewSource.View;
            }
        }

        public bool IsEmpty()
        {
            return this.FolderSets.Count() == 0;
        }


        private bool endEditing;
        [XmlIgnore]
        public bool EndEditing
        {
            get
            {
                return endEditing;
            }
            set
            {
                if (value == endEditing) return;
                endEditing = value;
                OnPropertyChanged("EndEditing");
            }
        }
    }
}