GoalBook - A Hybrid Smart Client

// <copyright file="NotesView.xaml.cs" company="GoalBook"> 
//    Copyright � 2009 Mark Brownsword. All rights reserved.
//    This source code and supporting files are licensed under The Code Project  
//    Open License (CPOL) as detailed at http://www.codeproject.com/info/cpol10.aspx. 
// </copyright> 
namespace GoalBook.Notes.Views
{
    #region Using Statements
    using System;
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Input;
    using GoalBook.Infrastructure.Comparers;
    using GoalBook.Infrastructure.Enums;
    using GoalBook.Infrastructure.Events;
    using GoalBook.Infrastructure.Interfaces;
    using GoalBook.Infrastructure.ObjectModel;
    using Infragistics.Windows.DataPresenter;
    using Infragistics.Windows.DataPresenter.Events;
    using Microsoft.Practices.Composite;
    #endregion

    /// <summary>
    /// Interaction logic for NotesView.xaml
    /// </summary>    
    public partial class NotesView : UserControl, IView, IActiveAware
    {
        #region Constants and Enums
        /// <summary>
        /// Declaration for IPersistenceService.
        /// </summary>
        private readonly IPersistenceService persistenceService;
        #endregion

        #region Instance and Shared Fields
        /// <summary>
        /// Declaration for isActive.
        /// </summary>
        private bool isActive;
        
        /// <summary>
        /// Declaration for isFirstload.
        /// </summary>
        private bool isFirstload;
        #endregion

        #region Constructors
        /// <summary>
        /// Initializes a new instance of the NotesView class.
        /// </summary>
        /// <param name="persistenceService">persistenceService parameter</param>        
        public NotesView(IPersistenceService persistenceService)
        {
            InitializeComponent();

            // Initialise service references.
            this.persistenceService = persistenceService;

            // Set FirstLoad.
            this.isFirstload = true;

            // Initialise the comparers for Folder field. A custom comparison is required because each 
            // Folder instance has an 'order' field that indicates the users preferred sort order for folders.                    
            foreach (Field field in this.xamDataGridNotes.FieldLayouts[0].Fields)
            {
                if (field.Label != null && field.Label.ToString() == Properties.Resources.LabelFolder)
                {
                    field.Settings.SortComparer = new FolderComparer(persistenceService.Folders);
                    field.Settings.GroupByComparer = new GroupedFolderComparer(persistenceService.Folders);
                    break;
                }
            }        
        }
        #endregion
        
        #region Delegates and Events
        /// <summary>
        /// Declaration for NoteSelected.
        /// </summary>
        public event EventHandler NoteSelected;

        /// <summary>
        /// Declaration for IsActiveChanged.
        /// </summary>
        public event EventHandler IsActiveChanged;

        /// <summary>
        /// Declaration for Activated.
        /// </summary>
        public event EventHandler Activated;

        /// <summary>
        /// Declaration for EditActionInitiated.
        /// </summary>
        public event EditActionEventHandler EditActionInitiated;
        #endregion

        #region Properties
        /// <summary>
        /// Gets or sets a value indicating whether IsActive. Note that Global Commands get
        /// their IsActive property set here.
        /// </summary>
        public bool IsActive
        {
            get 
            { 
                return this.isActive; 
            }

            set
            {
                if (this.isActive != value)
                {
                    this.isActive = value;
                    this.OnIsActiveChanged();
                }
            }
        }

        /// <summary>
        /// Gets count of Selected Notes.
        /// </summary>        
        public int SelectedNotesCount
        {
            get 
            {                
                return xamDataGridNotes.SelectedItems.Records.Count; 
            }
        }

        /// <summary>
        /// Gets selected Notes.
        /// </summary>        
        public SelectedRecordCollection SelectedNotes
        {
            get 
            {                
                return xamDataGridNotes.SelectedItems.Records; 
            }
        }
        #endregion
        
        #region Public and internal Methods
        /// <summary>
        /// Activate the module.
        /// </summary>
        public void Activate()
        {
            Mouse.SetCursor(Cursors.Wait);
            try
            {                
                this.OnActivated();
            }
            finally
            {
                Mouse.UpdateCursor();
            }
        }

        /// <summary>
        /// Refresh Sort Position.
        /// </summary>
        /// <param name="activeOnly">Flag indicating if only active record needs refreshing</param>
        public void RefreshSortPosition(bool activeOnly)
        {
            if (activeOnly)
            {
                if (xamDataGridNotes.ActiveRecord == null)
                {
                    return;
                }

                xamDataGridNotes.ActiveRecord.RefreshSortPosition();
            }
            else
            {
                xamDataGridNotes.Records.RefreshSort();
            }
        }

        /// <summary>
        /// Determine if module CanClose.
        /// </summary> 
        /// <returns>True if CanClose</returns>
        public bool CanClose()
        {
            return true;
        }

        /// <summary>
        /// Set Item Active.
        /// </summary>
        /// <param name="note">Note parameter</param>
        public void SetItemActive(Note note)
        {
            if (xamDataGridNotes.Records.Count == 0)
            {
                return;
            }

            foreach (Record record in xamDataGridNotes.Records)
            {
                if (record is DataRecord)
                {                        
                    DataRecord dataRecord = record as DataRecord;
                    if (dataRecord.DataItem is Note)
                    {
                        if ((dataRecord.DataItem as Note).NoteID == note.NoteID)
                        {
                            xamDataGridNotes.Focus();
                            xamDataGridNotes.ActiveRecord = record;
                            xamDataGridNotes.ActiveRecord.IsSelected = true;
                        }
                    }
                }
            }
        }
        #endregion               

        #region Base Class Overrides
        #endregion

        #region Private and Protected Methods
        /// <summary>
        /// Raise the IsActiveChanged event.
        /// </summary>
        protected virtual void OnIsActiveChanged()
        {
            EventHandler isActiveChangedHandler = this.IsActiveChanged;
            if (isActiveChangedHandler != null)
            {
                isActiveChangedHandler(this, EventArgs.Empty);
            }
        }

        /// <summary>
        /// Raise the Activated event.
        /// </summary>
        private void OnActivated()
        {
            EventHandler activatedHandler = this.Activated;
            if (activatedHandler != null)
            {
                activatedHandler(this, EventArgs.Empty);
            }
        }

        /// <summary>
        /// Raise the EditActionInitiated event.
        /// </summary>
        /// <param name="records">records parameter</param>
        /// <param name="editAction">editAction parameter</param>
        private void OnEditActionInitiated(SelectedRecordCollection records, EditActionType editAction)
        {
            EditActionEventHandler editActionInitiatedHandler = this.EditActionInitiated;
            if (editActionInitiatedHandler != null)
            {
                editActionInitiatedHandler(new EditActionEventArgs(records, editAction));
            }
        }

        /// <summary>
        /// Raise the NoteSelected event.
        /// </summary>
        private void OnNoteSelected()
        {
            EventHandler noteSelectedHandler = this.NoteSelected;
            if (noteSelectedHandler != null)
            {
                noteSelectedHandler(this, EventArgs.Empty);
            }
        }        
        #endregion
        
        #region Event Handlers
        /// <summary>
        /// Handle UserControl_Loaded event.
        /// </summary>
        /// <param name="sender">sender parameter</param>
        /// <param name="e">RoutedEventArgs parameter</param>
        private void UserControl_Loaded(object sender, RoutedEventArgs e)
        {
            if (xamDataGridNotes.Records.Count > 0 && this.isFirstload)
            {
                xamDataGridNotes.Focus();
                xamDataGridNotes.ActiveRecord = xamDataGridNotes.Records[0];
                xamDataGridNotes.ActiveRecord.IsSelected = true;
                this.isFirstload = false;
            }
        }

        /// <summary>
        /// Handle XamDataGridNotes_RecordsDeleting event.
        /// </summary>
        /// <param name="sender">sender parameter</param>
        /// <param name="e">RecordsDeletingEventArgs parameter</param>
        private void XamDataGridNotes_RecordsDeleting(object sender, RecordsDeletingEventArgs e)
        {
            e.DisplayPromptMessage = false;
            e.Cancel = true;
            
            // Note: Delete is handled by Delete Command in Presenter class.
        }

        /// <summary>
        /// Handle XamDataGridNotes_SelectedItemsChanged event.
        /// </summary>
        /// <param name="sender">sender parameter</param>
        /// <param name="e">SelectedItemsChangedEventArgs parameter</param>
        private void XamDataGridNotes_SelectedItemsChanged(object sender, SelectedItemsChangedEventArgs e)        
        {
            this.OnNoteSelected();            
        }        

        /// <summary>
        /// Handle XamDataGridNotes_MouseDoubleClick event.
        /// </summary>
        /// <param name="sender">sender parameter</param>
        /// <param name="e">MouseButtonEventArgs parameter</param>
        private void XamDataGridNotes_MouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            if (xamDataGridNotes.SelectedItems.Records.Count == 0) 
            { 
                return; 
            }

            this.OnEditActionInitiated(xamDataGridNotes.SelectedItems.Records, EditActionType.Edit);
        }        

        /// <summary>
        /// Handle XamDataGridNotes_KeyUp event.
        /// </summary>
        /// <param name="sender">sender parameter</param>
        /// <param name="e">KeyEventArgs parameter</param>
        private void XamDataGridNotes_KeyUp(object sender, KeyEventArgs e)
        {
            if (xamDataGridNotes.SelectedItems.Records.Count == 0) 
            { 
                return; 
            }

            if (e.Key == Key.Enter && e.KeyboardDevice.Modifiers == ModifierKeys.None)
            {
                this.OnEditActionInitiated(xamDataGridNotes.SelectedItems.Records, EditActionType.Edit);
            }     
        }
        #endregion
    }
}