/src/DocumentStrip.cs

/////////////////////////////////////////////////////////////////////////////////

// Paint.NET                                                                   //

// Copyright (C) dotPDN LLC, Rick Brewster, Tom Jackson, and contributors.     //

// Portions Copyright (C) Microsoft Corporation. All Rights Reserved.          //

// See src/Resources/Files/License.txt for full licensing and attribution      //

// details.                                                                    //

// .                                                                           //

/////////////////////////////////////////////////////////////////////////////////



using System.Linq;

using PaintDotNet.Base;

using PaintDotNet.SystemLayer;

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Drawing;

using System.Windows.Forms;



namespace PaintDotNet

{

    internal class DocumentStrip

        : ImageStrip,

          IDocumentList

    {

        private object _thumbsLock = new object();



        private readonly List<DocumentWorkspace> _documents = new List<DocumentWorkspace>();

        private readonly List<Item> _documentButtons = new List<Item>();

        private readonly Dictionary<DocumentWorkspace, Item> _dw2Button = new Dictionary<DocumentWorkspace, Item>();

        private Dictionary<DocumentWorkspace, RenderArgs> _thumbs = new Dictionary<DocumentWorkspace, RenderArgs>();

        private ThumbnailManager _thumbnailManager;

        private DocumentWorkspace _selectedDocument;

        private bool _ensureSelectedIsVisible = true;

        private int _suspendThumbnailUpdates;



        public void SuspendThumbnailUpdates()

        {

            ++_suspendThumbnailUpdates;

        }



        public void ResumeThumbnailUpdates()

        {

            --_suspendThumbnailUpdates;

        }



        public void SyncThumbnails()

        {

            if (_thumbnailManager.IsDisposed) return;

            using (new WaitCursorChanger(this))

            {

                _thumbnailManager.DrainQueue();

            }



            Refresh();

        }



        public int ThumbnailUpdateLatency

        {

            get

            {

                return _thumbnailManager.UpdateLatency;

            }



            set

            {

                _thumbnailManager.UpdateLatency = value;

            }

        }



        public bool EnsureSelectedIsVisible

        {

            get

            {

                return _ensureSelectedIsVisible;

            }



            set

            {

                if (_ensureSelectedIsVisible == value) return;

                _ensureSelectedIsVisible = value;

                PerformLayout();

            }

        }



        public DocumentWorkspace[] DocumentList

        {

            get

            {

                return _documents.ToArray();

            }

        }



        public Image[] DocumentThumbnails

        {

            get

            {

                SyncThumbnails();



                var thumbnails = new Image[_documents.Count];



                for (int i = 0; i < thumbnails.Length; ++i)

                {

                    DocumentWorkspace dw = _documents[i];

                    RenderArgs ra;



                    if (!_thumbs.TryGetValue(dw, out ra))

                    {

                        thumbnails[i] = null;

                    }

                    else

                    {

                        thumbnails[i] = ra.Bitmap;

                    }

                }



                return thumbnails;

            }

        }



        public int DocumentCount

        {

            get

            {

                return _documents.Count;

            }

        }



        public event EventHandler DocumentListChanged;

        protected virtual void OnDocumentListChanged()

        {

            if (DocumentListChanged != null)

            {

                DocumentListChanged(this, EventArgs.Empty);

            }

        }



        public DocumentWorkspace SelectedDocument

        {

            get

            {

                return _selectedDocument;

            }



            set

            {

                if (!_documents.Contains(value))

                {

                    throw new ArgumentException("DocumentWorkspace isn't being tracked by this instance of DocumentStrip");

                }



                if (_selectedDocument == value) return;

                SelectDocumentWorkspace(value);

                OnDocumentClicked(value, DocumentClickAction.Select);

                Refresh();

            }

        }



        public int SelectedDocumentIndex

        {

            get

            {

                return _documents.IndexOf(_selectedDocument);

            }

        }



        public override Size GetPreferredSize(Size proposedSize)

        {

            Size itemSize = ItemSize;

            int preferredWidth;



            if (ItemCount == 0)

            {

                preferredWidth = 0;

            }

            else

            {

                preferredWidth = itemSize.Width * DocumentCount;

            }



            var preferredSize = new Size(preferredWidth, itemSize.Height);

            return preferredSize;

        }



        private bool OnDigitHotKeyPressed(Keys keys)

        {

            // strip off the Alt and Control stuff

            keys &= ~Keys.Alt;

            keys &= ~Keys.Control;



            if (keys < Keys.D0 || keys > Keys.D9)

            {

                return false;

            }



            int digit = (int)keys - (int)Keys.D0;

            int index;



            if (digit == 0)

            {

                index = 9;

            }

            else

            {

                index = digit - 1;

            }



            if (index < _documents.Count)

            {

                PerformItemClick(index, ItemPart.Image, MouseButtons.Left);

                return true;

            }

            return false;

        }



        public DocumentStrip()

        {

            PdnBaseForm.RegisterFormHotKey(Keys.Control | Keys.Tab, OnNextTabHotKeyPressed);

            PdnBaseForm.RegisterFormHotKey(Keys.Control | Keys.PageDown, OnNextTabHotKeyPressed);

            PdnBaseForm.RegisterFormHotKey(Keys.Control | Keys.Shift | Keys.Tab, OnPreviousTabHotKeyPressed);

            PdnBaseForm.RegisterFormHotKey(Keys.Control | Keys.PageUp, OnPreviousTabHotKeyPressed);



            _thumbnailManager = new ThumbnailManager(this); // allow for a 1px black border



            InitializeComponent();



            for (int i = 0; i <= 9; ++i)

            {

                Keys digit = Utility.LetterOrDigitCharToKeys((char)(i + '0'));

                PdnBaseForm.RegisterFormHotKey(Keys.Control | digit, OnDigitHotKeyPressed);

                PdnBaseForm.RegisterFormHotKey(Keys.Alt | digit, OnDigitHotKeyPressed);

            }



            ShowCloseButtons = true;

        }



        private bool OnNextTabHotKeyPressed(Keys keys)

        {

            bool processed = NextTab();

            return processed;

        }



        private bool OnPreviousTabHotKeyPressed(Keys keys)

        {

            bool processed = PreviousTab();

            return processed;

        }



        public bool NextTab()

        {

            bool changed = false;



            if (_selectedDocument != null)

            {

                int currentIndex = _documents.IndexOf(_selectedDocument);

                int newIndex = (currentIndex + 1) % _documents.Count;

                SelectedDocument = _documents[newIndex];

                changed = true;

            }



            return changed;

        }



        public bool PreviousTab()

        {

            bool changed = false;



            if (_selectedDocument != null)

            {

                int currentIndex = _documents.IndexOf(_selectedDocument);

                int newIndex = (currentIndex + (_documents.Count - 1)) % _documents.Count;

                SelectedDocument = _documents[newIndex];

                changed = true;

            }



            return changed;

        }



        private void InitializeComponent()

        {

            Name = "DocumentStrip";

        }



        protected override void Dispose(bool disposing)

        {

            if (disposing)

            {

                while (_documents.Count > 0)

                {

                    RemoveDocumentWorkspace(_documents[_documents.Count - 1]);

                }



                if (_thumbnailManager != null)

                {

                    _thumbnailManager.Dispose();

                    _thumbnailManager = null;

                }



                foreach (RenderArgs ra in _thumbs.Keys.Select(dw => _thumbs[dw]))

                {

                    ra.Dispose();

                }



                _thumbs.Clear();

                _thumbs = null;

            }



            base.Dispose(disposing);

        }



        protected new void OnScrollArrowClicked(ArrowDirection arrowDirection)

        {

            int sign = 0;



            switch (arrowDirection)

            {

                case ArrowDirection.Left:

                    sign = -1;

                    break;



                case ArrowDirection.Right:

                    sign = +1;

                    break;

            }



            int delta = ItemSize.Width;



            ScrollOffset += sign * delta;



            base.OnScrollArrowClicked(arrowDirection);

        }

        

        protected override void OnItemClicked(Item item, ItemPart itemPart, MouseButtons mouseButtons)

        {

            var dw = item.Tag as DocumentWorkspace;



            if (dw != null)

            {

                switch (itemPart)

                {

                    case ItemPart.None:

                        // do nothing

                        break;



                    case ItemPart.CloseButton:

                        if (mouseButtons == MouseButtons.Left)

                        {

                            OnDocumentClicked(dw, DocumentClickAction.Close);

                        }

                        break;



                    case ItemPart.Image:

                        switch (mouseButtons)

                        {

                            case MouseButtons.Left:

                                SelectedDocument = dw;

                                break;

                            case MouseButtons.Right: //TODO: Right-click menu

                                break;

                        }

                        break;



                    default:

                        throw new InvalidEnumArgumentException();

                }

            }



            base.OnItemClicked(item, itemPart, mouseButtons);

        }



        public event EventHandler<EventArgs<Pair<DocumentWorkspace, DocumentClickAction>>> DocumentClicked;

        protected virtual void OnDocumentClicked(DocumentWorkspace dw, DocumentClickAction action)

        {

            if (DocumentClicked != null)

            {

                DocumentClicked(this, new EventArgs<Pair<DocumentWorkspace, DocumentClickAction>>(

                    Pair.Create(dw, action)));

            }

        }



        public void UnlockDocumentWorkspaceDirtyValue(DocumentWorkspace unlockMe)

        {

            Item docItem = _dw2Button[unlockMe];

            docItem.UnlockDirtyValue();

        }



        public void LockDocumentWorkspaceDirtyValue(DocumentWorkspace lockMe, bool forceDirtyValue)

        {

            Item docItem = _dw2Button[lockMe];

            docItem.LockDirtyValue(forceDirtyValue);

        }



        public void AddDocumentWorkspace(DocumentWorkspace addMe)

        {

            _documents.Add(addMe);



            var docButton = new Item {Image = null, Tag = addMe};



            AddItem(docButton);

            _documentButtons.Add(docButton);



            addMe.CompositionUpdated += WorkspaceCompositionUpdated;



            _dw2Button.Add(addMe, docButton);



            if (addMe.Document != null)

            {

                QueueThumbnailUpdate(addMe);

                docButton.Dirty = addMe.Document.Dirty;

                addMe.Document.DirtyChanged += DocumentDirtyChanged;

            }



            addMe.DocumentChanging += WorkspaceDocumentChanging;

            addMe.DocumentChanged += WorkspaceDocumentChanged;



            OnDocumentListChanged();

        }



        private void WorkspaceDocumentChanging(object sender, EventArgs<Document> e)

        {

            if (e.Data != null)

            {

                e.Data.DirtyChanged -= DocumentDirtyChanged;

            }

        }



        private void WorkspaceDocumentChanged(object sender, EventArgs e)

        {

            var dw = (DocumentWorkspace)sender;

            Item docButton = _dw2Button[dw];



            if (dw.Document != null)

            {

                docButton.Dirty = dw.Document.Dirty;

                dw.Document.DirtyChanged += DocumentDirtyChanged;

            }

            else

            {

                docButton.Dirty = false;

            }

        }



        private void DocumentDirtyChanged(object sender, EventArgs e)

        {

            foreach (Item docButton in

                from t in _documents where ReferenceEquals(sender, t.Document) select _dw2Button[t])

            {

                docButton.Dirty = ((Document)sender).Dirty;

            }

        }



        private void WorkspaceCompositionUpdated(object sender, EventArgs e)

        {

            var dw = (DocumentWorkspace)sender;

            QueueThumbnailUpdate(dw);

        }



        public void RemoveDocumentWorkspace(DocumentWorkspace removeMe)

        {

            removeMe.CompositionUpdated -= WorkspaceCompositionUpdated;



            if (_selectedDocument == removeMe)

            {

                _selectedDocument = null;

            }



            removeMe.DocumentChanging -= WorkspaceDocumentChanging;

            removeMe.DocumentChanged -= WorkspaceDocumentChanged;



            if (removeMe.Document != null)

            {

                removeMe.Document.DirtyChanged -= DocumentDirtyChanged;

            }



            _documents.Remove(removeMe);

            _thumbnailManager.RemoveFromQueue(removeMe);



            Item docButton = _dw2Button[removeMe];

            RemoveItem(docButton);

            _dw2Button.Remove(removeMe);

            _documentButtons.Remove(docButton);



            if (_thumbs.ContainsKey(removeMe))

            {

                RenderArgs thumbRa = _thumbs[removeMe];

                Surface surface = thumbRa.Surface;

                thumbRa.Dispose();

                _thumbs.Remove(removeMe);

                surface.Dispose();

            }



            OnDocumentListChanged();

        }



        protected override void OnLayout(LayoutEventArgs levent)

        {

            base.OnLayout(levent);



            if (!_ensureSelectedIsVisible || (Focused || LeftScrollButton.Focused || RightScrollButton.Focused)) return;

            int index = _documents.IndexOf(_selectedDocument);

            EnsureItemFullyVisible(index);

        }



        public void SelectDocumentWorkspace(DocumentWorkspace selectMe)

        {

            UI.SuspendControlPainting(this);



            _selectedDocument = selectMe;



            if (_thumbs.ContainsKey(selectMe))

            {

                RenderArgs thumb = _thumbs[selectMe];

                Bitmap bitmap = thumb.Bitmap;

            }

            else

            {

                QueueThumbnailUpdate(selectMe);

            }



            foreach (Item docItem in _documentButtons)

            {

                if ((docItem.Tag as DocumentWorkspace) == selectMe)

                {

                    EnsureItemFullyVisible(docItem);

                    docItem.Checked = true;

                }

                else

                {

                    docItem.Checked = false;

                }

            }



            UI.ResumeControlPainting(this);

            Invalidate(true);

        }



        public void RefreshThumbnail(DocumentWorkspace dw)

        {

            if (_documents.Contains(dw))

            {

                QueueThumbnailUpdate(dw);

            }

        }



        public void RefreshAllThumbnails()

        {

            foreach (DocumentWorkspace dw in _documents)

            {

                QueueThumbnailUpdate(dw);

            }

        }



        private void OnThumbnailUpdated(DocumentWorkspace dw)

        {

            // We must double check that the DW is still around, because there's a chance

            // that the DW was been removed while the thumbnail was being rendered.

            if (!_dw2Button.ContainsKey(dw)) return;

            Item docButton = _dw2Button[dw];

            RenderArgs docRA = _thumbs[dw];

            docButton.Image = docRA.Bitmap;

            docButton.Update();

        }



        public void QueueThumbnailUpdate(DocumentWorkspace dw)

        {

            if (_suspendThumbnailUpdates <= 0)

            {

                _thumbnailManager.QueueThumbnailUpdate(dw, PreferredImageSize.Width - 2, OnThumbnailRendered);

            }

        }



        private void OnThumbnailRendered(object sender, EventArgs<Pair<IThumbnailProvider, Surface>> e)

        {

            RenderArgs ra = null;

            var dw = (DocumentWorkspace)e.Data.First;



            var desiredSize = new Size(e.Data.Second.Width + 2, e.Data.Second.Height + 2);



            if (_thumbs.ContainsKey(dw))

            {

                ra = _thumbs[dw];



                if (ra.Size != desiredSize)

                {

                    ra.Dispose();

                    ra = null;



                    _thumbs.Remove(dw);

                }

            }

            

            if (ra == null)

            {

                var surface = new Surface(desiredSize);

                ra = new RenderArgs(surface);

                _thumbs.Add(dw, ra);

            }



            ra.Surface.Clear(ColorBgra.Black);

            ra.Surface.CopySurface(e.Data.Second, new Point(1, 1));

            e.Data.Second.Dispose();



            OnThumbnailUpdated(dw);

        }

    }

}