GoalBook - A Hybrid Smart Client

// <copyright file="TasksView.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.Tasks.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 TasksView.xaml
    /// </summary>
    public partial class TasksView : 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 TasksView class.
        /// </summary>
        /// <param name="persistenceService">persistenceService parameter</param>        
        public TasksView(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.xamDataGridTasks.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 TaskSelected.
        /// </summary>
        public event EventHandler TaskSelected;

        /// <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 Tasks.
        /// </summary>        
        public int SelectedTasksCount
        {
            get
            {
                return xamDataGridTasks.SelectedItems.Records.Count;
            }
        }

        /// <summary>
        /// Gets selected Tasks.
        /// </summary>        
        public SelectedRecordCollection SelectedTasks
        {
            get
            {
                return xamDataGridTasks.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 (xamDataGridTasks.ActiveRecord == null)
                {
                    return;
                }

                xamDataGridTasks.ActiveRecord.RefreshSortPosition();
            }
            else
            {
                xamDataGridTasks.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="task">Task parameter</param>
        public void SetItemActive(Task task)
        {
            if (xamDataGridTasks.Records.Count == 0)
            {
                return;
            }

            foreach (Record record in xamDataGridTasks.Records)
            {
                if (record is DataRecord)
                {
                    DataRecord dataRecord = record as DataRecord;
                    if (dataRecord.DataItem is Task)
                    {
                        if ((dataRecord.DataItem as Task).TaskID == task.TaskID)
                        {
                            xamDataGridTasks.Focus();
                            xamDataGridTasks.ActiveRecord = record;
                            xamDataGridTasks.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 TaskSelected event.
        /// </summary>
        private void OnTaskSelected()
        {
            EventHandler noteSelectedHandler = this.TaskSelected;
            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 (xamDataGridTasks.Records.Count > 0 && this.isFirstload)
            {
                xamDataGridTasks.Focus();
                xamDataGridTasks.ActiveRecord = xamDataGridTasks.Records[0];
                xamDataGridTasks.ActiveRecord.IsSelected = true;
                this.isFirstload = false;
            }
        }

        /// <summary>
        /// Handle XamDataGridTasks_RecordsDeleting event.
        /// </summary>
        /// <param name="sender">sender parameter</param>
        /// <param name="e">RecordsDeletingEventArgs parameter</param>
        private void XamDataGridTasks_RecordsDeleting(object sender, RecordsDeletingEventArgs e)
        {
            e.DisplayPromptMessage = false;
            e.Cancel = true;

            // Note: Delete is handled by Delete Command in Presenter class.
        }

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

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

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

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

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