#if FRAMEWORK20
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
using DevComponents.DotNetBar.ScrollBar;
using DevComponents.Schedule.Model;

namespace DevComponents.DotNetBar.Schedule
{
    public class TimeLineView : BaseView
    {
        #region Static variables

        static private AppointmentColor _appointmentColor = new AppointmentColor();

        #endregion

        #region Private variables

        private CalendarWeekDayColor _ViewColor =       // View display color table
            new CalendarWeekDayColor(eCalendarColor.Automatic);

        private List<CalendarItem>
            _CalendarItems = new List<CalendarItem>();

        private Point _LastMovePoint;           // Last mouse move Point
        private Point _LastPointOffset;         // Last Point offset
        private Rectangle _LastBounds;          // MouseDown item bounds

        private int _SelectedColStart;          // Column start selection
        private int _SelectedColEnd;            // Column end selection

        private Timer _ScrollViewTimer;         // Timer used to implement auto view scrolling
        private int _ScrollDwell;               // Scroll dwell (pause, throttle) counter

        private Color _WorkColor;               // Cached Brush colors
        private Color _OffWorkColor;
        private Color _SelectedColor;

        private Brush _WorkBrush;               // Cached Brushes
        private Brush _OffWorkBrush;
        private Brush _SelectedBrush;

        private int _HScrollPos;                // Horizontal scroll position

        private List<ColumnList> _CondensedColList;
        private List<int> _CollateLines = new List<int>();

        private bool _ModelReloaded = true;

        #endregion

        public TimeLineView(CalendarView calendarView, eCalendarView eCalendarView)
            : base(calendarView, eCalendarView)
        {
            // Set our non-client drawing info and CalendarColor

            NClientData = new NonClientData(
                eTabOrientation.Vertical,
                (int)eCalendarWeekDayPart.OwnerTabBorder,
                (int)eCalendarWeekDayPart.OwnerTabForeground,
                (int)eCalendarWeekDayPart.OwnerTabBackground,
                (int)eCalendarWeekDayPart.OwnerTabContentBackground,
                (int)eCalendarWeekDayPart.OwnerTabSelectedForeground,
                (int)eCalendarWeekDayPart.OwnerTabSelectedBackground);

            CalendarColorTable = _ViewColor;

            // Hook onto our events

            HookEvents(true);

            if (calendarView.TimeLineHScrollPanel.ScrollBar != null)
            {
                _HScrollPos = -calendarView.TimeLineHScrollPanel.ScrollBar.Value *
                    calendarView.TimeLineColumnWidth;
            }
        }

        #region Public properties

        #region CalendarItems

        /// <summary>
        /// Gets array of CalendarItems
        /// </summary>
        public List<CalendarItem> CalendarItems
        {
            get { return (_CalendarItems); }
        }

        #endregion

        #region StartDate

        /// <summary>
        /// Start date - readonly
        /// </summary>
        public new DateTime StartDate
        {
            get { return (base.StartDate); }
            internal set { base.StartDate = value; }
        }

        #endregion

        #region EndDate

        /// <summary>
        /// End date - readonly
        /// </summary>
        public new DateTime EndDate
        {
            get { return (base.EndDate); }
            internal set { base.EndDate = value; }
        }

        #endregion

        #region ColumnWidth

        /// <summary>
        /// Gets the ColumnWidth
        /// </summary>
        public int ColumnWidth
        {
            get { return (CalendarView.TimeLineColumnWidth); }
        }

        #endregion

        #region BaseInterval

        /// <summary>
        /// Gets the BaseInterval (interval in total minutes)
        /// </summary>
        public double BaseInterval
        {
            get { return (CalendarView.BaseInterval); }
        }

        #endregion

        #region TimeLineColumnCount

        /// <summary>
        /// Gets the number of Columns
        /// </summary>
        public int TimeLineColumnCount
        {
            get { return (CalendarView.TimeLineColumnCount); }
        }

        #endregion

        #region MinAppointmentWidth

        /// <summary>
        /// Gets the MinAppointmentWidth
        /// </summary>
        public int MinAppointmentWidth
        {
            get { return (CalendarView.TimeLineMinAppointmentWidth); }
        }

        #endregion

        #endregion

        #region Private properties

        #region ShowCondensed

        /// <summary>
        /// Gets the CondensedView visibility state
        /// </summary>
        private bool ShowCondensed
        {
            get
            {
                if (CalendarView.TimeLineCondensedViewVisibility == eCondensedViewVisibility.Hidden)
                    return (false);

                if (CalendarView.TimeLineCondensedViewHeight < 10)
                    return (false);

                if (CalendarView.TimeLineCondensedViewVisibility == eCondensedViewVisibility.AllResources)
                    return (true);

                return (CalendarView.SelectedOwnerIndex == DisplayedOwnerKeyIndex);
            }
        }

        #endregion

        #region Cached Brushes

        #region WorkBrush

        /// <summary>
        /// Gets and sets the Work time brush
        /// </summary>
        private Brush WorkBrush
        {
            get
            {
                Color color = _ViewColor.GetColor(
                    (int)eCalendarWeekDayPart.DayWorkHoursBackground);

                if (_WorkColor != color)
                {
                    _WorkColor = color;

                    WorkBrush = new SolidBrush(color);
                }

                return (_WorkBrush);
            }

            set
            {
                if (_WorkBrush != value)
                {
                    if (_WorkBrush != null)
                        _WorkBrush.Dispose();

                    _WorkBrush = value;
                }
            }
        }

        #endregion

        #region OffWorkBrush

        /// <summary>
        /// Gets and sets the Off-hours work time brush
        /// </summary>
        private Brush OffWorkBrush
        {
            get
            {
                Color color = _ViewColor.GetColor(
                    (int)eCalendarWeekDayPart.DayOffWorkHoursBackground);

                if (_OffWorkColor != color)
                {
                    _OffWorkColor = color;

                    OffWorkBrush = new SolidBrush(color);
                }

                return (_OffWorkBrush);
            }

            set
            {
                if (_OffWorkBrush != value)
                {
                    if (_OffWorkBrush != null)
                        _OffWorkBrush.Dispose();

                    _OffWorkBrush = value;
                }
            }
        }

        #endregion

        #region SelectedBrush

        /// <summary>
        /// Gets and sets the selected brush
        /// </summary>
        private Brush SelectedBrush
        {
            get
            {
                Color color = _ViewColor.GetColor(
                    (int)eCalendarWeekDayPart.SelectionBackground);

                if (_SelectedColor != color)
                {
                    _SelectedColor = color;

                    SelectedBrush = new SolidBrush(color);
                }

                return (_SelectedBrush);
            }

            set
            {
                if (_SelectedBrush != value)
                {
                    if (_SelectedBrush != null)
                        _SelectedBrush.Dispose();

                    _SelectedBrush = value;
                }
            }
        }

        #endregion

        #endregion

        #endregion

        #region Internal Properties

        /// <summary>
        /// Gets the first visible timeline column
        /// </summary>
        internal int FirstVisibleColumn
        {
            get { return (-_HScrollPos / ColumnWidth); }
        }

        /// <summary>
        /// Gets the condensed time line height
        /// </summary>
        internal int CondensedLineHeight
        {
            get { return (CalendarView.TimeLineCondensedViewHeight); }
        }

        /// <summary>
        /// Gets and sets the model reload state
        /// </summary>
        internal bool ModelReloaded
        {
            get { return (_ModelReloaded); }
            set { _ModelReloaded = value; }
        }

        #endregion

        #region Hook / Unhook Events

        /// <summary>
        /// Routine hooks all necessary events for this control
        /// </summary>
        /// <param name="hook">True to hook, false to unhook</param>
        private void HookEvents(bool hook)
        {
            if (hook == true)
            {
                CalendarView.SelectedViewChanged += SelectedViewChanged;
                CalendarView.SelectedOwnerChanged += SelectedOwnerChanged;

                CalendarView.TimeLineViewStartDateChanged += TimeLineViewStartDateChanged;
                CalendarView.TimeLineViewEndDateChanged += TimeLineViewEndDateChanged;
                CalendarView.TimeLineIntervalChanged += TimeLineIntervalChanged;
                CalendarView.TimeLineIntervalPeriodChanged += TimeLineIntervalPeriodChanged;
                CalendarView.TimeLineCondensedViewVisibilityChanged += TimeLineCondensedViewVisibilityChanged;

                CalendarView.TimeLineHScrollPanel.ScrollPanelChanged += ScrollPanelChanged;
            }
            else
            {
                CalendarView.SelectedViewChanged -= SelectedViewChanged;
                CalendarView.SelectedOwnerChanged -= SelectedOwnerChanged;

                CalendarView.TimeLineViewStartDateChanged -= TimeLineViewStartDateChanged;
                CalendarView.TimeLineViewEndDateChanged -= TimeLineViewEndDateChanged;
                CalendarView.TimeLineIntervalChanged -= TimeLineIntervalChanged;
                CalendarView.TimeLineIntervalPeriodChanged -= TimeLineIntervalPeriodChanged;
                CalendarView.TimeLineCondensedViewVisibilityChanged -= TimeLineCondensedViewVisibilityChanged;

                CalendarView.TimeLineHScrollPanel.ScrollPanelChanged -= ScrollPanelChanged;
            }
        }

        #endregion

        #region Event handling routines

        #region SelectedViewChanged

        /// <summary>
        /// Processes view changes
        /// </summary>
        /// <param name="sender">object</param>
        /// <param name="e">SelectedViewEventArgs</param>
        void SelectedViewChanged(object sender, SelectedViewEventArgs e)
        {
            // Update our IsViewSelected state

            IsViewSelected = (e.NewValue == ECalendarView);

            if (IsViewSelected == true)
            {
                AutoSyncViewDate(e.OldValue);
                UpdateDateSelection();
            }
            else
            {
                ResetView();
            }
        }

        #endregion

        #region SelectedOwnerChanged

        void SelectedOwnerChanged(object sender, SelectedOwnerChangedEventArgs e)
        {
            if (CalendarView.TimeLineStretchRowHeight == true)
            {
                if (CalendarView.TimeLineCondensedViewVisibility == eCondensedViewVisibility.SelectedResource)
                    NeedRecalcLayout = true;
            }
        }

        #endregion

        #region TimeLineViewStartDateChanged

        /// <summary>
        /// Processes StartDate changes
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void TimeLineViewStartDateChanged(object sender, DateChangeEventArgs e)
        {
            StartDate = e.NewValue;
        }

        #endregion

        #region TimeLineViewEndDateChanged

        /// <summary>
        /// Processes EndDate changes
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void TimeLineViewEndDateChanged(object sender, DateChangeEventArgs e)
        {
            EndDate = e.NewValue;
        }

        #endregion

        #region TimeLineIntervalPeriodChanged

        /// <summary>
        /// Handles IntervalPeriodChange notification
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void TimeLineIntervalPeriodChanged(object sender, TimeLineIntervalPeriodChangedEventArgs e)
        {
            NeedRecalcSize = true;
            NeedRecalcLayout = true;
        }

        #endregion

        #region TimeLineIntervalChanged

        /// <summary>
        /// Handles IntervalChange notification
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void TimeLineIntervalChanged(object sender, TimeLineIntervalChangedEventArgs e)
        {
            NeedRecalcSize = true;
            NeedRecalcLayout = true;
        }

        #endregion

        #region TimeLineCondensedViewVisibilityChanged

        void TimeLineCondensedViewVisibilityChanged(
            object sender, TimeLineCondensedViewVisibilityChangedEventArgs e)
        {
            if (CalendarView.TimeLineStretchRowHeight == true)
                NeedRecalcLayout = true;
        }

        #endregion

        #region ScrollPanelChanged

        /// <summary>
        /// Handles ScrollPanel change notification
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void ScrollPanelChanged(object sender, EventArgs e)
        {
            TimeLineHScrollPanel panel = sender as TimeLineHScrollPanel;

            if (panel != null)
            {
                HScrollBarAdv hScrollBar = panel.ScrollBar;

                _HScrollPos = -hScrollBar.Value * CalendarView.TimeLineColumnWidth;

                // Redraw our view

                if (Displayed == true)
                {
                    NeedRecalcLayout = true;

                    InvalidateRect(true);
                    Refresh();
                }
            }
        }

        #endregion

        #endregion

        #region GetViewAreaFromPoint

        /// <summary>
        /// Gets the view area under the given mouse
        /// point (tab, header, content, etc)
        /// </summary>
        /// <param name="pt">Point</param>
        /// <returns>eViewArea</returns>
        public override eViewArea GetViewAreaFromPoint(Point pt)
        {
            if (Bounds.Contains(pt) == true)
            {
                if (pt.X >= ClientRect.X)
                {
                    // CondensedView

                    if (ShowCondensed == true)
                    {
                        if (GetCondensedRect().Contains(pt) == true)
                            return (eViewArea.InCondensedView);
                    }

                    return (eViewArea.InContent);
                }

                return (base.GetViewAreaFromPoint(pt));
            }

            return (eViewArea.NotInView);
        }

        #endregion

        #region GetDateSelectionFromPoint

        /// <summary>
        /// Gets the date selection from the given point. The startDate
        /// and endDate will vary based upon the view type
        /// </summary>
        /// <param name="pt">Point in question</param>
        /// <param name="startDate">out start date</param>
        /// <param name="endDate">out end date</param>
        /// <returns>True if a valid selection exists
        /// at the given point</returns>
        public override bool GetDateSelectionFromPoint(
            Point pt, out DateTime startDate, out DateTime endDate)
        {
            base.GetDateSelectionFromPoint(pt, out startDate, out endDate);

            int col;

            if (GetPointItem(pt, out col, true) == true)
            {
                startDate = CalendarView.TimeLineAddInterval(StartDate, col);
                endDate = CalendarView.TimeLineAddInterval(startDate, 1);

                return (true);
            }

            return (false);
        }

        #endregion

        #region SetSelectedItem

        /// <summary>
        /// Handles selected item changes
        /// </summary>
        /// <param name="sender">CalendarItem</param>
        /// <param name="e">EventArgs</param>
        public void ItemIsSelectedChanged(object sender, EventArgs e)
        {
            CalendarItem ci = sender as CalendarItem;

            if (ci != null)
            {
                if (ci.IsSelected == true)
                {
                    if (SelectedItem != null && ci != SelectedItem)
                        SelectedItem.IsSelected = false;

                    SelectedItem = ci;
                }
                else
                {
                    if (ci == SelectedItem)
                        SelectedItem = null;
                }

                // Make sure the selection is reflected
                // in the condensed view (if present)

                if (ShowCondensed == true)
                    InvalidateRect(GetCondensedRect());
            }
        }

        /// <summary>
        /// Sets the current selected item
        /// </summary>
        /// <param name="pci">Previous CalendarItem</param>
        /// <param name="nci">New CalendarItem</param>
        /// <returns>New selected CalendarItem</returns>
        protected override CalendarItem SetSelectedItem(CalendarItem pci, CalendarItem nci)
        {
            if (nci != null)
                nci.IsSelected = true;

            else if (pci != null)
                pci.IsSelected = false;

            return (nci);
        }

        #endregion

        #region UpdateDateSelection

        /// <summary>
        /// Updates our slice selection range to reflect
        /// the given date selection start and end values
        /// </summary>
        protected override void UpdateDateSelection()
        {
            if (IsViewSelected == true)
            {
                // Get the new absolute slice selection range

                int colStart = GetDateCol(DateSelectionStart);
                int colEnd = GetDateCol(DateSelectionEnd);

                // Limit our range to only those columns
                // that are visible on the screen

                int c1 = -_HScrollPos / ColumnWidth;
                int c2 = c1 + ClientRect.Width / ColumnWidth + 1;

                if (c2 > c1)
                {
                    ProcessSelRange(colStart, colEnd, c1, c2);

                    // Save our new selection range

                    _SelectedColStart = colStart;
                    _SelectedColEnd = colEnd;
                }

                if (ShowCondensed == true)
                {
                    Rectangle r = GetCondensedRect();

                    this.InvalidateRect(r);
                }
            }
        }

        /// <summary>
        /// Processes the selection time column range
        /// </summary>
        /// <param name="colStart">Column range start</param>
        /// <param name="colEnd">Column range end</param>
        /// <param name="c1">Column start limit</param>
        /// <param name="c2">Column end limit</param>
        private void ProcessSelRange(int colStart, int colEnd, int c1, int c2)
        {
            bool[] oldSelected = SelectedColumns(c1, c2, _SelectedColStart, _SelectedColEnd);
            bool[] newSelected = SelectedColumns(c1, c2, colStart, colEnd);

            // Invalidate those slices whose
            // selection status changed

            Rectangle r = GetColRect(c1);

            if (r.Width > 0 && r.Height > 0)
            {
                for (int i = 0; i < c2 - c1; i++)
                {
                    if (oldSelected[i] != newSelected[i])
                        InvalidateRect(r);

                    r.X += ColumnWidth;
                }
            }
        }

        /// <summary>
        /// Gets an array of column selection values
        /// over the given range of columns
        /// </summary>
        /// <param name="c1">Column start limit</param>
        /// <param name="c2">Column end limit</param>
        /// <param name="colStart">Slice range start</param>
        /// <param name="colEnd">Slice range end</param>
        /// <returns>Array of selection values</returns>
        private bool[] SelectedColumns(int c1, int c2, int colStart, int colEnd)
        {
            // Calculate our number of entries and
            // allocate our IsSelected array accordingly

            int n = c2 - c1;
            bool[] sel = new bool[n + 1];

            // Loop through the range of entries determining if
            // the specific col is within the selection range

            for (int i = 0; i < n; i++)
                sel[i] = (c1 + i >= colStart && c1 + i < colEnd);

            // Return the array to the caller

            return (sel);
        }

        #endregion

        #region RecalcSize routines

        /// <summary>
        /// Performs NeedRecalcSize requests
        /// </summary>
        public override void RecalcSize()
        {
            base.RecalcSize();

            if (IsViewSelected == true)
            {
                // Normalize our start and end dates

                DateTime startDate;
                DateTime endDate;
                NormalizeDates(out startDate, out endDate);

                // Update our Model connection view,
                // CalendarItems, and DateSelection

                UpdateView();
                UpdateDateSelection();
            }

            NeedRecalcLayout = false;
        }

        #region NormalizeDates

        /// <summary>
        /// Normalizes the user specified start and end dates
        /// </summary>
        /// <param name="startDate">[out] Normalized start date</param>
        /// <param name="endDate">[out] Normalized end date</param>
        protected virtual void NormalizeDates(out DateTime startDate, out DateTime endDate)
        {
            startDate = this.StartDate;
            endDate = this.EndDate;
        }

        #endregion

        #region UpdateView

        /// <summary>
        /// Updates our connection model view
        /// </summary>
        private void UpdateView()
        {
            // Make sure we have a model connection

            if (Connector == null)
            {
                if (CalendarModel != null)
                    Connector = new ModelTimeLineViewConnector(CalendarModel, this);
            }
            else
            {
                // The timeline range could have changed, so let
                // the connection refresh the data if needed

                ((ModelTimeLineViewConnector)Connector).RefreshData(false);
            }

            // We have a connection, so update our CalendarItems

            if (Connector != null)
            {
                UpdateCalendarItems();

                if (ShowCondensed == true)
                    UpdateCondensedColumnList();

                CalendarView.DoViewLoadComplete(this);
            }
        }

        #endregion

        #region ResetView

        /// <summary>
        /// Disconnects and resets the Model connection
        /// </summary>
        internal override void ResetView()
        {
            _ModelReloaded = true;

            base.ResetView();
        }

        #endregion

        #region UpdateCalendarItems

        /// <summary>
        /// Updates our CalendarItems list
        /// </summary>
        private void UpdateCalendarItems()
        {
            if (NeedRecalcLayout == true)
            {
                _CollateLines.Clear();

                if (_CalendarItems.Count > 0)
                {
                    List<CalendarItem> items = SortCalendarItems(_CalendarItems);

                    if (CalendarView.HasTimeLineGetRowCollateIdCallout)
                    {
                        SortedDictionary<int, List<CalendarItem>> ditems = CollateCalendarItems(items);

                        int dy = 0;

                        foreach (KeyValuePair<int, List<CalendarItem>> kvp in ditems)
                        {
                            ColumnList colList = new ColumnList();

                            for (int i = 0; i < kvp.Value.Count; i++)
                                colList.AddColumnSlot(kvp.Value[i], 0);

                            colList.CountColumns();

                            dy = CalcAppointmentBounds(colList, dy, true);

                            _CollateLines.Add(dy);
                        }
                    }
                    else
                    {
                        ColumnList colList = new ColumnList();

                        for (int i = 0; i < items.Count; i++)
                            colList.AddColumnSlot(items[i], 0);

                        colList.CountColumns();

                        CalcAppointmentBounds(colList, 0, false);
                    }
                }

                NeedRecalcLayout = false;

                InvalidateRect();
            }
        }

        #region CollateCalendarItems

        private SortedDictionary<int, List<CalendarItem>>
            CollateCalendarItems(List<CalendarItem> items)
        {
            SortedDictionary<int, List<CalendarItem>> citems =
                new SortedDictionary<int, List<CalendarItem>>();

            for (int i = 0; i < items.Count; i++)
            {
                if (items[i].CollateId < 0)
                {
                    TimeLineGetRowCollateIdEventArgs e =
                        new TimeLineGetRowCollateIdEventArgs(items[i]);

                    CalendarView.DoTimeLineGetRowCollateId(e);

                    items[i].CollateId = e.CollateId;
                }

                int collateId = items[i].CollateId;

                if (citems.ContainsKey(collateId) == false)
                    citems.Add(collateId, new List<CalendarItem>());

                citems[collateId].Add(items[i]);
            }

            return (citems);
        }

        #endregion

        #region SortCalendarItems

        /// <summary>
        /// Sorts the provided CalendarItems
        /// </summary>
        /// <returns>Sorted CalendarItems</returns>
        private List<CalendarItem> SortCalendarItems(IEnumerable<CalendarItem> clist)
        {
            List<CalendarItem> items = new List<CalendarItem>();

            items.AddRange(clist);

            if (items.Count > 0)
            {
                items.Sort(

                   delegate(CalendarItem c1, CalendarItem c2)
                   {
                       if (c1.StartTime > c2.StartTime)
                           return (1);

                       if (c1.StartTime < c2.StartTime)
                           return (-1);

                       if (c1.EndTime < c2.EndTime)
                           return (1);

                       if (c1.EndTime > c2.EndTime)
                           return (-1);

                       int result = 0;
                       CalendarView.DoDetailSortEvent(this, c1, c2, ref result);

                       return (result);
                   }
               );
            }

            return (items);
        }

        #endregion

        #region CalcAppointmentBounds

        /// <summary>
        /// Calculates normal appointment bounds
        /// </summary>
        /// <param name="colList">Accumulated ColumnList</param>
        /// <param name="dy"></param>
        /// <param name="collate"></param>
        private int CalcAppointmentBounds(ColumnList colList, int dy, bool collate)
        {
            if (colList.SList.Count > 0)
            {
                // If we are stretching the rows height, then calculate
                // the default row height and the row spread, to evenly
                // distribute the fill remainder

                bool stretchRow = (collate == false && 
                    CalendarView.TimeLineStretchRowHeight == true);

                int height = GetColRect(0).Height;

                int rowSpread;
                int rowHeight = GetColumnRowHeight(colList.SList.Count, stretchRow, height, out rowSpread) - 2;

                for (int i = 0; i < colList.SList.Count; i++)
                {
                    int maxRowHeight = 0;

                    for (int j = 0; j < colList.SList[i].Count; j++)
                    {
                        SlotItem sitem = colList.SList[i][j];
                        CalendarItem item = sitem.CItem;

                        Rectangle r = new Rectangle();

                        r.Y = ClientRect.Y + dy;
                        r.Height = rowHeight;

                        if (stretchRow == false)
                            r.Height = GetRowHeight(item, rowHeight);

                        TimeSpan ts1 = item.StartTime - StartDate;
                        TimeSpan ts2 = item.EndTime - item.StartTime;

                        int pos = (int) ((ts1.TotalMinutes * ColumnWidth) / BaseInterval);
                        int width = (int) ((ts2.TotalMinutes * ColumnWidth) / BaseInterval);

                        if (CalendarView.TimeLinePeriod == eTimeLinePeriod.Years)
                        {
                            int years = item.StartTime.Year - StartDate.Year;

                            pos = (years * ColumnWidth) / CalendarView.TimeLineInterval;
                        }

                        if (width < MinAppointmentWidth)
                            width = MinAppointmentWidth;

                        if (width < 4)
                            width = 4;

                        r.X = ClientRect.X + pos + _HScrollPos;
                        r.Width = width;

                        Rectangle p = ClientRect;
                        int hpad = CalendarView.TimeLineHorizontalPadding;

                        if (r.Left >= p.Left)
                        {
                            r.X += hpad;
                            r.Width -= hpad;
                        }

                        if (r.Right <= p.Right)
                            r.Width -= hpad;

                        if (i < rowSpread)
                            r.Height++;

                        if (item.StartTime != item.EndTime)
                        {
                            if (r.Height + 2 > maxRowHeight)
                                maxRowHeight = r.Height + 2;
                        }

                        if (stretchRow == true)
                        {
                            if (CalendarView.TimeLineStretchRowHeightMode == TimeLineStretchRowHeightMode.Full)
                            {
                                if (sitem.SList == null)
                                {
                                    r.Height = height - dy - 2;
                                }
                                else
                                {
                                    int n = GetColumnCount(sitem);

                                    r.Height = (rowHeight + 1) * n - 1;

                                    for (int k = 0; k < n; k++)
                                    {
                                        if (i + k >= rowSpread)
                                            break;

                                        r.Height++;
                                    }
                                }
                            }
                        }
                            
                        r.Height++;

                        item.Bounds = r;

                        // Set it's display state

                        item.Displayed = r.IntersectsWith(ClientRect);
                    }

                    dy += maxRowHeight;
                }
            }

            return (dy);
        }

        #region GetColumnCount

        private int GetColumnCount(SlotItem sitem)
        {
            int column = int.MaxValue;

            for (int i = 0; i < sitem.SList.Count; i++)
            {
                if (sitem.SList[i].Column < column)
                    column = sitem.SList[i].Column;
            }

            return (column - sitem.Column);
        }

        #endregion

        #region GetColumnRowHeight

        private int GetColumnRowHeight(int count, bool stretchRow, int height, out int rowSpread)
        {
            rowSpread = 0;

            int rowHeight = AppointmentHeight;

            if (stretchRow == true)
            {
                rowHeight = height / count;

                if (rowHeight < AppointmentHeight)
                    rowHeight = AppointmentHeight;
                else
                    rowSpread = height - (count * rowHeight);
            }

            return (rowHeight);
        }

        #endregion

        #region GetRowHeight

        /// <summary>
        /// Get the RowHeight for the given CalendarItem
        /// </summary>
        /// <param name="item">CalendarItem</param>
        /// <param name="height">Calculated height</param>
        /// <returns></returns>
        private int GetRowHeight(CalendarItem item, int height)
        {
            TimeLineGetRowHeightEventArgs e =
                new TimeLineGetRowHeightEventArgs(item, height);

            CalendarView.DoTimeLineGetRowHeight(e);

            return (e.Height);
        }

        #endregion

        #endregion

        #endregion

        #region UpdateCondensedColumnList

        /// <summary>
        /// Updates the condensed view column list
        /// </summary>
        internal void UpdateCondensedColumnList()
        {
            if (_ModelReloaded == true && Connector != null)
            {
                _CondensedColList = new List<ColumnList>();

                List<CalendarItem> items = new List<CalendarItem>();

                // Get our appointment collection

                GetCondensedAppts(items);
                GetCondensedCustomItems(items);

                // If we have any items, sort them and
                // create a corresponding ColumnList

                if (items.Count > 0)
                {
                    items = SortCalendarItems(items);

                    if (CalendarView.HasTimeLineGetRowCollateIdCallout)
                    {
                        SortedDictionary<int, List<CalendarItem>> ditems = CollateCalendarItems(items);

                        foreach (KeyValuePair<int, List<CalendarItem>> kvp in ditems)
                        {
                            ColumnList colList = new ColumnList();

                            for (int i = 0; i < kvp.Value.Count; i++)
                                colList.AddColumnSlot(kvp.Value[i], 0);

                            colList.CountColumns();

                            _CondensedColList.Add(colList);
                        }
                    }
                    else
                    {
                        _CondensedColList.Add(new ColumnList());

                        for (int i = 0; i < items.Count; i++)
                            _CondensedColList[0].AddColumnSlot(items[i], 0);

                        _CondensedColList[0].CountColumns();
                    }
                }

                _ModelReloaded = false;
            }
        }

        #region GetCondensedAppts

        private void GetCondensedAppts(List<CalendarItem> items)
        {
            List<Appointment> appts =
                ((ModelTimeLineViewConnector)Connector).ListAppts;

            if (appts != null && appts.Count > 0)
            {
                int n = Math.Min(appts.Count, 500);
                n = Math.Max(appts.Count / n, 1);

                for (int i = 0; i < appts.Count; i += n)
                {
                    if (IsAppointmentVisible(appts[i]) == true)
                    {
                        CalendarItem ci = new CalendarItem();

                        ci.StartTime = appts[i].StartTime;
                        ci.EndTime = appts[i].EndTime;
                        ci.ModelItem = appts[i];

                        items.Add(ci);
                    }
                }
            }
        }

        /// <summary>
        /// Determines if an appointment is visible
        /// for the given DisplayOwner
        /// </summary>
        /// <param name="app"></param>
        /// <returns></returns>
        private bool IsAppointmentVisible(Appointment app)
        {
            if (string.IsNullOrEmpty(DisplayedOwnerKey))
                return (true);

            return (app.OwnerKey == DisplayedOwnerKey);
        }

        #endregion

        #region GetCondensedCustomItems

        private void GetCondensedCustomItems(List<CalendarItem> items)
        {
            for (int i = 0; i < CalendarView.CustomItems.Count; i++)
            {
                CustomCalendarItem item = CalendarView.CustomItems[i];

                if (IsCustomItemVisible(item) == true &&
                    (item.StartTime < EndDate && item.EndTime > StartDate))
                {
                    CalendarItem ci = new CalendarItem();

                    ci.StartTime = item.StartTime;
                    ci.EndTime = item.EndTime;
                    ci.ModelItem = item;

                    items.Add(ci);
                }
            }
        }

        private bool IsCustomItemVisible(CustomCalendarItem item)
        {
            if (string.IsNullOrEmpty(Connector.DisplayOwnerKey))
                return (true);

            return (item.OwnerKey.Equals(Connector.DisplayOwnerKey));
        }

        #endregion

        #endregion

        #endregion

        #region Paint processing

        #region Root paint code

        /// <summary>
        /// Paint processing
        /// </summary>
        /// <param name="e">ItemPaintArgs</param>
        public override void Paint(ItemPaintArgs e)
        {
            Graphics g = e.Graphics;

            // Set our current color table

            _ViewColor.SetColorTable();

            // calculate our Column count and range

            int colStart, colEnd;

            if (GetColRange(e, out colStart, out colEnd) > 0)
            {
                Region rgnSave = g.Clip;

                g.SetClip(ClientRect, CombineMode.Intersect);

                // Draw the TimeLine

                DrawTimeLine(g, colStart, colEnd);
                DrawTimeIndicators(g, colStart, colEnd, eTimeIndicatorLevel.Bottom);

                if (Connector != null && ShowCondensed == true)
                    DrawCondensedLine(g);

                // If we have a model connection then
                // draw our appointments

                if (Connector != null && Connector.IsConnected)
                {
                    Rectangle r = ClientRect;
                    r.X += 1;

                    if (ShowCondensed == true)
                    {
                        Rectangle r2 = GetCondensedRect();

                        if (r.Bottom > r2.Top)
                            r.Height -= (r.Bottom - r2.Top);
                    }

                    g.SetClip(r, CombineMode.Intersect);

                    DrawAppointments(e);
                }

                DrawTimeIndicators(g, colStart, colEnd, eTimeIndicatorLevel.Top);

                g.Clip = rgnSave;

                // Update our pos window

                UpdatePosWin(ClientRect);
            }

            // Let the base painting take place

            base.Paint(e);
        }

        #endregion

        #region DrawTimeLine

        /// <summary>
        /// Initiates the drawing of the TimeLine
        /// </summary>
        /// <param name="g">Graphics</param>
        /// <param name="colStart">Starting column</param>
        /// <param name="colEnd">Ending column</param>
        private void DrawTimeLine(Graphics g, int colStart, int colEnd)
        {
            int n = colEnd - colStart;

            eSlotDisplayState[] states = new eSlotDisplayState[n + 1];

            for (int i = 0; i <= n; i++)
                states[i] = GetSlotState(colStart + i);

            DrawContent(g, colStart, colEnd, states);
            DrawBorder(g, colStart, colEnd, states);
        }

        #region DrawContent

        /// <summary>
        /// Draws the content area of the TimeLine
        /// </summary>
        /// <param name="g"></param>
        /// <param name="colStart">Starting column</param>
        /// <param name="colEnd">Ending column</param>
        /// <param name="states"></param>
        private void DrawContent(Graphics g,
            int colStart, int colEnd, eSlotDisplayState[] states)
        {
            Rectangle r = GetColRect(colStart);

            if (CalendarView.HasTimeLineSlotBackgroundCallout == true)
            {
                for (int i = colStart; i <= colEnd; i++)
                {
                    int n = i - colStart;

                    DateTime startTime = StartDate.AddMinutes(i * BaseInterval);
                    DateTime endTime = startTime.AddMinutes(BaseInterval);

                    if (CalendarView.DoTimeLineViewPreRenderSlotBackground(
                        g, this, startTime, endTime, r, ref states[n]) == false)
                    {
                        g.FillRectangle(GetContentBrush(states[n]), r);

                        DrawCollateLines(g, r);

                        CalendarView.DoTimeLineViewPostRenderSlotBackground(
                            g, this, startTime, endTime, r, states[n]);
                    }

                    r.X += ColumnWidth;
                }
            }
            else
            {
                Rectangle t = r;

                for (int i = 0; i <= colEnd - colStart; i++)
                {
                    g.FillRectangle(GetContentBrush(states[i]), t);

                    t.X += ColumnWidth;
                }

                r.Width += (t.Right - r.Right);

                DrawCollateLines(g, r);
            }
        }

        #region DrawCollateLines

        private void DrawCollateLines(Graphics g, Rectangle r)
        {
            if (CalendarView.TimeLineShowCollateLines == true &&
                _CollateLines.Count > 1)
            {
                using (Pen pen = new Pen(
                    _ViewColor.GetColor((int) eCalendarWeekDayPart.DayHalfHourBorder)))
                {
                    for (int i = 0; i < _CollateLines.Count - 1; i++)
                    {
                        int y = _CollateLines[i];

                        g.DrawLine(pen, r.X, r.Y + y, r.Right, r.Y + y);
                    }
                }
            }
        }

        #endregion

        #region GetSlotState

        /// <summary>
        /// GetSlotState
        /// </summary>
        /// <param name="col"></param>
        /// <returns></returns>
        private eSlotDisplayState GetSlotState(int col)
        {
            eSlotDisplayState state = eSlotDisplayState.None;

            if (DisplayedOwnerKeyIndex == CalendarView.SelectedOwnerIndex)
            {
                if (col >= _SelectedColStart && col < _SelectedColEnd)
                    state |= eSlotDisplayState.Selected;
            }

            DateTime date = StartDate.AddMinutes(col * CalendarView.BaseInterval);
            WorkTime workTime = new WorkTime(date.Hour, date.Minute);

            if (IsWorkTime((int)date.DayOfWeek, workTime) == true)
                state |= eSlotDisplayState.Work;

            return (state);
        }

        #endregion

        #region GetContentBrush

        /// <summary>
        /// Gets the background content brush
        /// for the given time slice
        /// </summary>
        /// <returns>Background brush</returns>
        private Brush GetContentBrush(eSlotDisplayState state)
        {
            if ((state & eSlotDisplayState.Selected) == eSlotDisplayState.Selected)
                return (SelectedBrush);

            if ((state & eSlotDisplayState.Work) == eSlotDisplayState.Work)
                return (WorkBrush);

            return (OffWorkBrush);
        }

        #endregion

        #region IsWorkTime

        /// <summary>
        /// Determines if the given time is tagged as a "Work time"
        /// </summary>
        /// <param name="day">Day of week</param>
        /// <param name="time">WorkTime to test</param>
        /// <returns>true if specified "time" is a Work time</returns>
        private bool IsWorkTime(int day, WorkTime time)
        {
            ModelTimeLineViewConnector tlc =
                (ModelTimeLineViewConnector)Connector;

            WorkTime workStartTime = tlc.DayInfo[day].WorkStartTime;
            WorkTime workEndTime = tlc.DayInfo[day].WorkEndTime;

            return (time >= workStartTime && time < workEndTime);
        }

        #endregion

        #endregion

        #region DrawBorder

        /// <summary>
        /// Draws the TimeLine border
        /// </summary>
        /// <param name="g"></param>
        /// <param name="colStart">Starting column</param>
        /// <param name="colEnd">Ending column</param>
        /// <param name="states"></param>
        private void DrawBorder(Graphics g,
            int colStart, int colEnd, eSlotDisplayState[] states)
        {
            Rectangle r = GetColRect(colStart);

            // Draw the vertical borders

            if (CalendarView.TimeLinePeriod == eTimeLinePeriod.Minutes)
                DrawHalfHourBorders(g, colStart, colEnd, r, states);
            else
                DrawHourBorders(g, colStart, colEnd, r, states);

            // Now draw the horizontal border

            r.Width = (colEnd - colStart + 1) * ColumnWidth;
            r.Height = ClientRect.Height;

            Color color = _ViewColor.GetColor((int)eCalendarWeekDayPart.DayViewBorder);

            if (CalendarView.DoTimeLineViewRenderViewBorder(g, this, colStart, colEnd, r, color) == false)
            {
                using (Pen pen1 = new Pen(color))
                {
                    Point pt1 = new Point(r.X, r.Bottom - 1);
                    Point pt2 = new Point(r.Right - 1, pt1.Y);

                    g.DrawLine(pen1, pt1, pt2);

                    if (CalendarView.TimeLineShowPeriodHeader == false &&
                        CalendarView.TimeLineShowIntervalHeader == false)
                    {
                        pt1 = new Point(r.X, r.Top);
                        pt2 = new Point(r.Right - 1, pt1.Y);

                        g.DrawLine(pen1, pt1, pt2);
                    }
                }
            }
        }

        #region DrawHalfHourBorders

        /// <summary>
        /// DrawHalfHourBorders
        /// </summary>
        /// <param name="g"></param>
        /// <param name="colStart"></param>
        /// <param name="colEnd"></param>
        /// <param name="bounds"></param>
        /// <param name="states"></param>
        private void DrawHalfHourBorders(Graphics g,
            int colStart, int colEnd, Rectangle bounds, eSlotDisplayState[] states)
        {
            // Draw the vertical hour and half hour borders

            using (Pen pen1 = new Pen(
                _ViewColor.GetColor((int)eCalendarWeekDayPart.DayHourBorder)))
            {
                using (Pen pen2 = new Pen(
                    _ViewColor.GetColor((int)eCalendarWeekDayPart.DayHalfHourBorder)))
                {
                    Point pt1 = new Point(bounds.X, ClientRect.Y);
                    Point pt2 = new Point(bounds.X, ClientRect.Bottom - 1);

                    int n = 60 / CalendarView.TimeLineInterval;
                    int start = -_HScrollPos / ColumnWidth;

                    for (int i = colStart; i <= colEnd; i++)
                    {
                        bool isHour = (i == start || (i % n) == 0);
                        Pen pen = (isHour ? pen1 : pen2);

                        if (CalendarView.DoTimeLineViewRenderSlotBorder(
                            g, this, i, isHour, states[i - colStart], pt1, pt2, pen) == false)
                        {
                            g.DrawLine((isHour ? pen1 : pen2), pt1, pt2);
                        }

                        pt1.X = pt2.X = (pt1.X + ColumnWidth);
                    }
                }
            }
        }

        #endregion

        #region DrawHourBorders

        /// <summary>
        /// DrawHourBorders
        /// </summary>
        /// <param name="g"></param>
        /// <param name="colStart"></param>
        /// <param name="colEnd"></param>
        /// <param name="bounds"></param>
        /// <param name="states"></param>
        private void DrawHourBorders(Graphics g,
            int colStart, int colEnd, Rectangle bounds, eSlotDisplayState[] states)
        {
            // Draw the vertical hour borders

            using (Pen pen = new Pen(
                _ViewColor.GetColor((int)eCalendarWeekDayPart.DayHourBorder)))
            {
                Point pt1 = new Point(bounds.X, ClientRect.Y);
                Point pt2 = new Point(bounds.X, ClientRect.Bottom - 1);

                for (int i = colStart; i <= colEnd; i++)
                {
                    if (CalendarView.DoTimeLineViewRenderSlotBorder(
                        g, this, i, true, states[i - colStart], pt1, pt2, pen) == false)
                    {
                        g.DrawLine(pen, pt1, pt2);
                    }

                    pt1.X = pt2.X = (pt1.X + ColumnWidth);
                }
            }
        }

        #endregion

        #endregion

        #region DrawTimeIndicators

        #region DrawTimeIndicators

        /// <summary>
        /// Draws view TimeIndicators
        /// </summary>
        /// <param name="g"></param>
        /// <param name="colStart"></param>
        /// <param name="colEnd"></param>
        private void DrawTimeIndicators(Graphics g, 
            int colStart, int colEnd, eTimeIndicatorLevel level)
        {
            DateTime start = CalendarView.TimeLineAddInterval(StartDate, colStart);
            DateTime end = CalendarView.TimeLineAddInterval(StartDate, colEnd);

            Rectangle r = Rectangle.Union(GetColRect(colStart), GetColRect(colEnd));

            for (int i = 0; i < CalendarView.TimeIndicators.Count; i++)
            {
                TimeIndicator ti = CalendarView.TimeIndicators[i];

                if (ti.IndicatorLevel == level)
                {
                    if (ti.IndicatorArea == eTimeIndicatorArea.All ||
                        ti.IndicatorArea == eTimeIndicatorArea.Content)
                    {
                        if (ti.IsVisible(CalendarView, this))
                        {
                            DateTime time = ti.IndicatorDisplayTime;

                            if (time >= start && time < end)
                                DrawTimeIndicator(g, start, r, ti);
                        }
                    }
                }
            }
        }

        #endregion

        #region DrawTimeIndicator

        #region DrawTimeIndicator

        /// <summary>
        /// Draws individual view TimeIndicator
        /// </summary>
        /// <param name="g"></param>
        /// <param name="startDate"></param>
        /// <param name="sRect"></param>
        /// <param name="ti"></param>
        private void DrawTimeIndicator(Graphics g,
            DateTime startDate, Rectangle sRect, TimeIndicator ti)
        {
            Rectangle r = GetIndicatorRect(ti, startDate, sRect);

            if (r.IntersectsWith(sRect) == true)
            {
                if (r.Width > 0)
                {
                    ColorDef cdef = GetIndicatorColor(ti);

                    if (cdef != null)
                    {
                        float angle = cdef.Angle - 90;

                        using (Brush br = _ViewColor.BrushPart(cdef, r, angle))
                        {
                            if (br is LinearGradientBrush)
                                ((LinearGradientBrush) br).WrapMode = WrapMode.TileFlipX;

                            g.FillRectangle(br, r);
                        }
                    }
                }

                Color color = GetIndicatorBorder(ti);

                if (color.IsEmpty == false)
                {
                    using (Pen pen = new Pen(color))
                        g.DrawLine(pen, r.Right, r.Top, r.Right, r.Bottom - 1);
                }
            }
        }

        #endregion

        #region GetIndicatorColor

        /// <summary>
        /// Gets the Indicator Back color
        /// </summary>
        /// <param name="ti"></param>
        /// <returns></returns>
        private ColorDef GetIndicatorColor(TimeIndicator ti)
        {
            ColorDef cdef = ti.IndicatorColor;

            if (cdef == null || cdef.IsEmpty == true)
                cdef = _ViewColor.GetColorDef((int)eCalendarWeekDayPart.TimeIndicator);

            return (cdef);
        }

        #endregion

        #region GetIndicatorBorder

        /// <summary>
        /// Gets the Indicator Border color
        /// </summary>
        /// <param name="ti"></param>
        /// <returns></returns>
        private Color GetIndicatorBorder(TimeIndicator ti)
        {
            return (ti.BorderColor.IsEmpty == false ? ti.BorderColor :
                _ViewColor.GetColor((int)eCalendarWeekDayPart.TimeIndicatorBorder));
        }

        #endregion

        #endregion

        #region GetIndicatorRect

        /// <summary>
        /// Gets the TimeIndicator Rectangle
        /// </summary>
        /// <param name="ti"></param>
        /// <param name="startDate"></param>
        /// <param name="sRect"></param>
        /// <returns></returns>
        private Rectangle GetIndicatorRect(
            TimeIndicator ti, DateTime startDate, Rectangle sRect)
        {
            double x = ColumnWidth / CalendarView.BaseInterval;

            int offset = (int)((ti.IndicatorDisplayTime - startDate).TotalMinutes * x);

            sRect.X += (offset - ti.Thickness - 1);
            sRect.Width = ti.Thickness;

            return (sRect);
        }

        /// <summary>
        /// Gets the TimeIndicator Rectangle
        /// </summary>
        /// <param name="ti"></param>
        /// <returns></returns>
        internal override Rectangle GetIndicatorRect(TimeIndicator ti)
        {
            return (GetIndicatorRect(ti, ti.IndicatorDisplayTime));
        }

        /// <summary>
        /// Gets the TimeIndicator Rectangle for the given date
        /// </summary>
        /// <param name="ti"></param>
        /// <param name="time"></param>
        /// <returns></returns>
        internal override Rectangle GetIndicatorRect(TimeIndicator ti, DateTime time)
        {
            int colStart = -_HScrollPos / ColumnWidth;
            DateTime startDate = CalendarView.TimeLineAddInterval(StartDate, colStart);

            double x = ColumnWidth / CalendarView.BaseInterval;
            int offset = (int)((time - startDate).TotalMinutes * x);

            Rectangle r = GetColRect(colStart);

            r.X += (offset - ti.Thickness - 1);
            r.Width = ti.Thickness;

            return (r);
        }

        #endregion

        #endregion

        #endregion

        #region DrawCondensedLine

        /// <summary>
        /// Draws the condensed TimeLine
        /// </summary>
        /// <param name="g"></param>
        private void DrawCondensedLine(Graphics g)
        {
            TimeSpan ts0 = EndDate - StartDate;
            float scale = (float)(ClientRect.Width / (ts0.TotalMinutes + BaseInterval));

            Rectangle r = GetCondensedRect();

            using (GraphicsPath path = GetCondensedViewPath(r, scale))
            {
                using (Brush br =
                    _ViewColor.BrushPart((int)eCalendarWeekDayPart.CondensedViewBackground, r))
                {
                    g.FillRectangle(br, r);
                }

                g.FillPath(Brushes.White, path);

                DrawCondensedContent(g, r, scale);
                DrawCondensedAppointments(g, scale);

                g.DrawPath(Pens.Gray, path);
            }
        }

        #region DrawCondensedContent

        /// <summary>
        /// Draws the Condensed Content area
        /// </summary>
        /// <param name="g"></param>
        /// <param name="vRect"></param>
        /// <param name="scale"></param>
        private void DrawCondensedContent(Graphics g, Rectangle vRect, float scale)
        {
            using (Pen pen = new Pen(
                _ViewColor.GetColor((int)eCalendarWeekDayPart.DayHourBorder)))
            {
                int selCols = _SelectedColEnd - _SelectedColStart;

                if (selCols > 0)
                {
                    Rectangle r = vRect;

                    r.X += (int)(_SelectedColStart * BaseInterval * scale);
                    r.Width = (int)(selCols * BaseInterval * scale);

                    using (Brush br =
                        _ViewColor.BrushPart((int)eCalendarWeekDayPart.DayOffWorkHoursBackground, r))
                    {
                        g.FillRectangle(br, r);
                    }

                    g.DrawRectangle(pen, r);
                }

                g.DrawLine(pen, vRect.Left, vRect.Y, vRect.Right, vRect.Y);
            }
        }

        #endregion

        #region GetCondensedViewPath

        /// <summary>
        /// Gets the condensed view display path
        /// </summary>
        /// <param name="scale">Scale factor</param>
        /// <param name="vRect">Condensed view rect</param>
        /// <returns>Path</returns>
        private GraphicsPath GetCondensedViewPath(Rectangle vRect, float scale)
        {
            int pos = (int)(FirstVisibleColumn * BaseInterval * scale);
            int width = (int)((BaseInterval * ClientRect.Width) / ColumnWidth * scale);

            Rectangle r = new
                Rectangle(ClientRect.X + pos, vRect.Y, width, vRect.Height);

            r.Inflate(0, -1);

            return (DisplayHelp.GetRoundedRectanglePath(r, 2, 2, 2, 2));
        }

        #endregion

        #region DrawCondensedAppointments

        /// <summary>
        /// Draws condensed appointments
        /// </summary>
        /// <param name="g">Graphics</param>
        /// <param name="scale">Scale factor</param>
        private void DrawCondensedAppointments(Graphics g, float scale)
        {
            // Display each item

            SmoothingMode saveMode = g.SmoothingMode;
            g.SmoothingMode = SmoothingMode.None;

            int dy = 3;

            foreach (ColumnList clist in _CondensedColList)
            {
                for (int i = 0; i < clist.SList.Count; i++)
                {
                    for (int j = 0; j < clist.SList[i].Count; j++)
                    {
                        CalendarItem item = clist.SList[i][j].CItem;

                        TimeSpan ts1 = item.StartTime - StartDate;
                        TimeSpan ts2 = item.EndTime - item.StartTime;

                        int pos = (int)(ts1.TotalMinutes * scale);
                        int width = (int)(ts2.TotalMinutes * scale);

                        if (width < 4)
                            width = 4;

                        Point pt1 = new Point(ClientRect.X + pos,
                                              ClientRect.Bottom - CondensedLineHeight + (i * 3) + dy);

                        Point pt2 = new Point(pt1.X + width, pt1.Y);

                        using (Pen pen = GetCondensedPen(item.ModelItem))
                            g.DrawLine(pen, pt1, pt2);
                    }
                }

                dy += (clist.SList.Count * 3);
            }

            g.SmoothingMode = saveMode;
        }

        #region GetCondensedPen

        /// <summary>
        /// Gets the appointments condensed pen
        /// </summary>
        /// <param name="o">Appointment object</param>
        /// <returns></returns>
        private Pen GetCondensedPen(object o)
        {
            string category = null;

            if (o is Appointment)
                category = (o as Appointment).CategoryColor;

            else if (o is CustomCalendarItem)
                category = (o as CustomCalendarItem).CategoryColor;

            if (category != null)
            {
                // Check to see if we have any user defined
                // AppointmentCategoryColors

                if (CalendarView.HasCategoryColors == true)
                {
                    AppointmentCategoryColor acc =
                        CalendarView.CategoryColors[category];

                    if (acc != null)
                    {
                        ColorDef cdef = acc.BackColor;

                        return (new Pen(cdef.Colors[cdef.Colors.Length - 1], 2));
                    }
                }

                if (category.Equals(Appointment.CategoryBlue))
                    return (GetCategoryPen(eAppointmentPart.BlueBackground));

                if (category.Equals(Appointment.CategoryGreen))
                    return (GetCategoryPen(eAppointmentPart.GreenBackground));

                if (category.Equals(Appointment.CategoryOrange))
                    return (GetCategoryPen(eAppointmentPart.OrangeBackground));

                if (category.Equals(Appointment.CategoryPurple))
                    return (GetCategoryPen(eAppointmentPart.PurpleBackground));

                if (category.Equals(Appointment.CategoryRed))
                    return (GetCategoryPen(eAppointmentPart.RedBackground));

                if (category.Equals(Appointment.CategoryYellow))
                    return (GetCategoryPen(eAppointmentPart.YellowBackground));
            }

            return (GetCategoryPen(eAppointmentPart.DefaultBackground));
        }

        #endregion

        #region GetCategoryPen

        /// <summary>
        /// GetCategoryPen
        /// </summary>
        /// <param name="part"></param>
        /// <returns></returns>
        private Pen GetCategoryPen(eAppointmentPart part)
        {
            ColorDef cdef = _appointmentColor.GetColorDef((int)part);

            return (new Pen(cdef.Colors[cdef.Colors.Length - 1], 2));
        }

        #endregion

        #endregion

        #endregion

        #region DrawAppointments

        /// <summary>
        /// Draws TimeLine appointments
        /// </summary>
        /// <param name="e"></param>
        private void DrawAppointments(ItemPaintArgs e)
        {
            List<CalendarItem> items = CalendarItems;

            if (items.Count > 0)
            {
                // Loop through each CalendarItem in the week

                int selItem = -1;

                for (int i = 0; i < items.Count; i++)
                {
                    // If we can display the item, then initiate the paint

                    if (items[i].Displayed == true)
                    {
                        if (e.ClipRectangle.IsEmpty ||
                            e.ClipRectangle.IntersectsWith(items[i].DisplayRectangle))
                        {
                            if (items[i].IsSelected == true)
                                selItem = i;
                            else
                                items[i].Paint(e);
                        }
                    }
                }

                if (selItem >= 0)
                {
                    for (int i = 0; i < items.Count; i++)
                    {
                        // If we can display the item, then initiate the paint

                        if (items[i].Displayed == true)
                        {
                            if (e.ClipRectangle.IsEmpty ||
                                e.ClipRectangle.IntersectsWith(items[i].DisplayRectangle))
                            {
                                if (items[i].IsSelected == true)
                                    items[i].Paint(e);
                            }
                        }
                    }
                }
            }
        }

        #endregion

        #region GetColRange

        /// <summary>
        /// Calculates the range of columns needed to be drawn
        /// to satisfy the specified paint request
        /// </summary>
        /// <param name="e">ItemPaintArgs</param>
        /// <param name="colStart">[out] Column start index</param>
        /// <param name="colEnd">[out] Column end index</param>
        /// <returns>Column range count (end - start)</returns>
        private int GetColRange(ItemPaintArgs e, out int colStart, out int colEnd)
        {
            // Calc our starting index

            int start = -_HScrollPos / ColumnWidth;
            int x = ClientRect.X + start * ColumnWidth + _HScrollPos;

            while (start < TimeLineColumnCount)
            {
                if (x + ColumnWidth > e.ClipRectangle.X)
                    break;

                x += ColumnWidth;

                start++;
            }

            // Calc our ending index

            int end = start;

            while (end < TimeLineColumnCount)
            {
                if (x >= e.ClipRectangle.Right)
                    break;

                x += ColumnWidth;

                end++;
            }

            end++;

            // Set the user supplied 'out' values, and
            // return the range count to the caller

            if (end - start == 0)
            {
                colStart = 0;
                colEnd = 0;

                return (0);
            }

            colStart = start;
            colEnd = end;

            return (end - start);
        }

        #endregion

        #endregion

        #region GetColRect

        /// <summary>
        /// Gets the display rectangle for the given column
        /// </summary>
        /// <param name="col">Column</param>
        /// <returns>Display rectangle</returns>
        private Rectangle GetColRect(int col)
        {
            Rectangle r = ClientRect;

            r.X += ((col * ColumnWidth) + _HScrollPos);
            r.Width = ColumnWidth;

            r.Height -= 1;

            if (ShowCondensed == true)
                r.Height -= (CondensedLineHeight - 1);

            return (r);
        }

        #endregion

        #region GetCondensedRect

        /// <summary>
        /// Gets the CondensedView rectangle
        /// </summary>
        /// <returns>CondensedView rectangle</returns>
        private Rectangle GetCondensedRect()
        {
            Rectangle r = ClientRect;

            r.X += 1;
            r.Width -= 1;

            r.Y = r.Bottom - CondensedLineHeight;
            r.Height = CondensedLineHeight - 1;

            return (r);
        }

        #endregion

        #region GetDateCol

        /// <summary>
        /// Gets the absolute column value for the given date
        /// </summary>
        /// <param name="selDate">Selection date</param>
        /// <returns>Absolute column</returns>
        private int GetDateCol(DateTime? selDate)
        {
            if (selDate.HasValue)
            {
                TimeSpan ts = selDate.Value - StartDate;

                return (int)(ts.TotalMinutes / CalendarView.BaseInterval);
            }

            return (0);
        }

        #endregion

        #region Mouse routines

        #region MouseDown processing

        /// <summary>
        /// MouseDown event processing
        /// </summary>
        /// <param name="objArg"></param>
        public override void InternalMouseDown(MouseEventArgs objArg)
        {
            // Forward on the event

            base.InternalMouseDown(objArg);

            if (objArg.Button == MouseButtons.Left)
            {
                if (IsTabMoving == false)
                {
                    // Locate where the event took place

                    if (ClientRect.Contains(objArg.Location) == true)
                    {
                        if (PointInCondensedView(objArg.Location) == true)
                        {
                            // User is mousing in the CondensedView area

                            MyCursor = Cursors.Hand;

                            ProcessCvlButtonDown(objArg);

                            IsCondMoving = true;
                        }
                        else
                        {
                            int col;

                            if (GetPointItem(objArg.Location, out col, true) == true)
                            {
                                // User is mouseing in the Content area

                                MyCursor = GetContentCursor();

                                if (ProcessCilButtonDown(objArg) == false)
                                    ProcessTvlButtonDown(col);

                                IsMouseDown = true;
                            }

                            IsCopyDrag = false;
                        }
                    }
                }
            }
        }

        #region CondensedView MouseDown processing

        /// <summary>
        /// Handles CondensedView Left Button Down events
        /// </summary>
        /// <param name="objArg"></param>
        private void ProcessCvlButtonDown(MouseEventArgs objArg)
        {
            ProcessCvlPoint(objArg);
        }

        #region ProcessCvlPoint

        /// <summary>
        /// Processes CondensedView point selection
        /// </summary>
        /// <param name="objArg"></param>
        private void ProcessCvlPoint(MouseEventArgs objArg)
        {
            TimeSpan ts0 = EndDate - StartDate;

            float scale = (float)((ClientRect.Width + 2) / ts0.TotalMinutes);
            int width = (int)((BaseInterval * ClientRect.Width) / ColumnWidth * scale);

            double x = (objArg.Location.X - ClientRect.X - (width / 2)) / scale;
            int col = (int)(x / BaseInterval);

            // Make sure we stay within our bounds, and
            // then set our new scroll value accordingly

            HScrollBarAdv hScrollBar = CalendarView.TimeLineHScrollPanel.ScrollBar;

            if (col < hScrollBar.Minimum)
                col = hScrollBar.Minimum;

            if (col > hScrollBar.Maximum - hScrollBar.LargeChange)
                col = hScrollBar.Maximum - hScrollBar.LargeChange;

            hScrollBar.Value = col;
        }

        #endregion

        #endregion

        #region CalendarItem MouseDown processing

        /// <summary>
        /// CalendarItem left mouseDown processing
        /// </summary>
        /// <param name="objArg">MouseEventArgs</param>
        private bool ProcessCilButtonDown(MouseEventArgs objArg)
        {
            CalendarItem item = m_HotSubItem as CalendarItem;

            if (item != null)
            {
                if (item.HitArea != CalendarItem.eHitArea.None)
                {
                    // Give the user a chance to cancel the
                    // operation before it starts

                    if (CalendarView.DoBeforeAppointmentViewChange(this, item,
                        ((item.HitArea == CalendarItem.eHitArea.Move) ?
                        eViewOperation.AppointmentMove : eViewOperation.AppointmentResize)) == false)
                    {
                        _LastBounds = item.Bounds;
                        _LastPointOffset = objArg.Location;
                        _LastMovePoint = objArg.Location;

                        if (IsResizing == false && IsMoving == false)
                        {
                            OldStartTime = item.StartTime;
                            OldEndTime = item.EndTime;
                            OldOwnerKey = OwnerKey;
                        }

                        // Flag appropriate action

                        if (item.HitArea == CalendarItem.eHitArea.LeftResize)
                            IsStartResizing = true;

                        else if (item.HitArea == CalendarItem.eHitArea.RightResize)
                            IsEndResizing = true;

                        else if (item.HitArea == CalendarItem.eHitArea.Move)
                            IsMoving = true;

                        // Update our initial PosWin display

                        UpdatePosWin(ClientRect);
                    }
                }

                return (true);
            }

            return (false);
        }

        #endregion

        #region TimeLineView MouseDown processing

        /// <summary>
        /// Handles TimeLineView left MouseDown events
        /// </summary>
        /// <param name="col">Column index</param>
        private void ProcessTvlButtonDown(int col)
        {
            DateTime startDate = CalendarView.TimeLineAddInterval(StartDate, col);
            DateTime endDate = CalendarView.TimeLineAddInterval(startDate, 1);

            ExtendSelection(ref startDate, ref endDate);

            CalendarView.DateSelectionStart = startDate;
            CalendarView.DateSelectionEnd = endDate;

            SelectedItem = null;
        }

        #endregion

        #endregion

        #region MouseUp processing

        /// <summary>
        /// MouseUp event processing
        /// </summary>
        /// <param name="objArg">MouseEventArgs</param>
        public override void InternalMouseUp(MouseEventArgs objArg)
        {
            base.InternalMouseUp(objArg);

            // Cancel our scroll timer

            CancelScrollTimer();
        }

        #endregion

        #region MouseMove processing

        /// <summary>
        /// MouseMove event processing
        /// </summary>
        /// <param name="objArg">MouseEventArgs</param>
        public override void InternalMouseMove(MouseEventArgs objArg)
        {
            // Forward on the event, but only if we are not in
            // the middle of moving or resizing a CalendarItem

            if (Control.MouseButtons == MouseButtons.None)
                ClearMouseStates();

            if (!IsMoving && !IsStartResizing && !IsEndResizing)
                base.InternalMouseMove(objArg);

            if (IsTabMoving == false)
            {
                if (IsCondMoving == true || PointInCondensedView(objArg.Location) == true)
                {
                    // The user in the CondensedView area

                    MyCursor = Cursors.Hand;

                    if (IsCondMoving == true)
                        ProcessCvlMouseMove(objArg);
                }
                else
                {
                    // The user in the Content area

                    MyCursor = GetContentCursor();

                    if (objArg.Button == MouseButtons.Left)
                        ProcessContentMove(objArg);
                }
            }
        }

        #region ProcessCvlMouseMove

        /// <summary>
        /// Handles CondensedView mouse moves
        /// </summary>
        /// <param name="objArg"></param>
        private void ProcessCvlMouseMove(MouseEventArgs objArg)
        {
            ProcessCvlPoint(objArg);
        }

        #endregion

        #region ProcessContentMove

        /// <summary>
        /// Processes content mouse moves
        /// </summary>
        /// <param name="objArg">MouseEventArgs</param>
        private void ProcessContentMove(MouseEventArgs objArg)
        {
            // Locate where the event took place
            // and process it accordingly

            int col;

            if (GetPointItem(objArg.Location, out col, false) == true)
            {
                // The col is visible, so no need to
                // enable scrolling - just process the event

                EnableViewScrolling(false);

                ProcessMouseMove(col, objArg);
            }
            else if (IsMouseDown == true)
            {
                // Check to see if the user is performing
                // a "DragDrop" operation

                if (DragDropAppointment(objArg) == false)
                {
                    // The selected slice is not visible,
                    // so we need to enable scrolling

                    EnableViewScrolling(true);

                    // Only process the event if the user is selecting
                    // time cells (auto moving apps is intrusive looking)

                    if (DateSelectionAnchor != null)
                        ProcessMouseMove(col, objArg);
                }
            }
        }

        #region DragDropAppointment

        /// <summary>
        /// Initiates a user "DragDrop" operation - if enabled
        /// </summary>
        /// <param name="objArgs"></param>
        /// <returns>True if operation started</returns>
        private bool DragDropAppointment(MouseEventArgs objArgs)
        {
            if (IsMoving == true && CanDrag == true)
            {
                Point pt = objArgs.Location;
                BaseView bv = CalendarView.GetViewFromPoint(pt);
                TimeLineView tlv = bv as TimeLineView;

                if (tlv != null && tlv != this)
                {
                    eViewArea area = bv.GetViewAreaFromPoint(pt);

                    if (area == eViewArea.InContent)
                    {
                        if (CalendarView.DoAppointmentViewChanging(SelectedItem, tlv.OwnerKey, SelectedItem.StartTime,
                            SelectedItem.EndTime, eViewOperation.AppointmentMove, IsNewCopyDrag) == false)
                        {
                            DragCopy();

                            ClearMouseStates();
                            CancelScrollTimer();

                            if (PosWin != null)
                                PosWin.Hide();

                            AppointmentView av = SelectedItem as AppointmentView;

                            if (av != null)
                                return (tlv.DragAppointment(this, av));

                            CustomCalendarItem ci = SelectedItem as CustomCalendarItem;

                            if (ci != null)
                                return (tlv.DragCustomItem(this, ci));
                        }
                    }
                }
            }

            return (false);
        }

        #region DragCustomItem

        private bool DragCustomItem(TimeLineView pv, CustomCalendarItem ci)
        {
            // Set the new owner and selected view, and
            // recalc the new layout

            ci.OwnerKey = OwnerKey;

            NeedRecalcLayout = true;
            RecalcSize();

            CalendarView.SelectedOwnerIndex = this.DisplayedOwnerKeyIndex;

            // Get the new view

            CustomCalendarItem view = GetCustomCalendarItem(ci);

            if (view != null)
                SetNewDragItem(pv, view);

            return (true);
        }

        #endregion

        #region DragAppointment

        /// <summary>
        /// Drags the given appointment from one view to another
        /// </summary>
        /// <param name="pv">Previous view</param>
        /// <param name="av">Item to drag</param>
        private bool DragAppointment(TimeLineView pv, AppointmentView av)
        {
            // Set the new owner and selected view, and
            // recalc the new layout

            av.Appointment.OwnerKey = OwnerKey;

            NeedRecalcLayout = true;
            RecalcSize();

            CalendarView.SelectedOwnerIndex = this.DisplayedOwnerKeyIndex;

            // Get the new view

            AppointmentView view = GetAppointmentView(av.Appointment);

            if (view != null)
                SetNewDragItem(pv, view);

            return (true);
        }

        #endregion

        #region SetNewDragItem

        private void SetNewDragItem(TimeLineView pv, CalendarItem view)
        {
            _LastBounds = pv._LastBounds;
            _LastMovePoint = pv._LastMovePoint;
            _LastPointOffset = pv._LastPointOffset;

            int dx = _LastPointOffset.X - _LastBounds.X;

            CalendarView.CalendarPanel.InternalMouseMove(new
                MouseEventArgs(MouseButtons.None, 0, view.Bounds.X + dx, view.Bounds.Y, 0));

            MouseEventArgs args = new
                MouseEventArgs(MouseButtons.Left, 1, view.Bounds.X + dx, view.Bounds.Y, 0);

            IsMoving = true;

            InternalMouseMove(args);
            CalendarView.CalendarPanel.InternalMouseDown(args);

            SelectedItem = view;

            IsCopyDrag = true;
        }

        #endregion

        #endregion

        #endregion

        #region GetContentCursor
        /// <summary>
        /// Gets the cursor
        /// </summary>
        /// <returns>Cursor</returns>
        private Cursor GetContentCursor()
        {
            CalendarItem item = m_HotSubItem as CalendarItem;

            if (item != null)
            {
                switch (item.HitArea)
                {
                    case CalendarItem.eHitArea.LeftResize:
                    case CalendarItem.eHitArea.RightResize:
                        return (Cursors.SizeWE);

                    case CalendarItem.eHitArea.Move:
                        return (IsMoving ? Cursors.SizeAll : DefaultCursor);
                }
            }

            return (DefaultCursor);
        }

        #endregion

        #region ProcessMouseMove

        /// <summary>
        /// Processes user MouseMove
        /// </summary>
        /// <param name="col">DayColumn</param>
        /// <param name="objArg"></param>
        private void ProcessMouseMove(int col, MouseEventArgs objArg)
        {
            if (DateSelectionAnchor != null)
            {
                ProcessTvMouseMove(col);
            }
            else if (SelectedItem != null)
            {
                if (objArg.Location.Equals(_LastMovePoint) == false)
                {
                    if (IsMoving == true)
                        ProcessItemMove(col, objArg);

                    else if (IsStartResizing == true)
                        ProcessItemLeftResize(col, objArg);

                    else if (IsEndResizing == true)
                        ProcessItemRightResize(col, objArg);

                    _LastMovePoint = objArg.Location;
                }
            }
        }

        #endregion

        #region ProcessTvMouseMove

        /// <summary>
        /// Processes TimeLineView mouseMove events
        /// </summary>
        /// <param name="col">Column</param>
        private void ProcessTvMouseMove(int col)
        {
            if (DateSelectionAnchor != null)
            {
                DateTime date = CalendarView.TimeLineAddInterval(StartDate, col);

                // Let the user select forwards or backwards

                if (date >= DateSelectionAnchor)
                {
                    CalendarView.DateSelectionStart = DateSelectionAnchor.Value;
                    CalendarView.DateSelectionEnd = CalendarView.TimeLineAddInterval(date, 1);
                }
                else
                {
                    CalendarView.DateSelectionStart = date;
                    CalendarView.DateSelectionEnd = CalendarView.TimeLineAddInterval(DateSelectionAnchor.Value, 1);
                }
            }
        }

        #endregion

        #region CalendarItem MouseMove processing

        /// <summary>
        /// Processes CalendarItem mouseMove events
        /// </summary>
        /// <param name="col">Column</param>
        /// <param name="objArg">MouseEventArgs</param>
        private void ProcessItemMove(int col, MouseEventArgs objArg)
        {
            // Calculate our new item date

            DateTime newDate;

            if (CalendarView.TimeLinePeriod == eTimeLinePeriod.Years)
            {
                newDate = StartDate.AddYears(
                    GetDeltaYears(col, true, objArg));
            }
            else
            {
                newDate = StartDate.AddMinutes(
                    GetDeltaMinutes(col, true, objArg));
            }

            if (newDate != SelectedItem.StartTime)
            {
                if (DragCopy() == false)
                {
                    TimeSpan ts = SelectedItem.EndTime - SelectedItem.StartTime;

                    try
                    {
                        if (SelectedItem is CustomCalendarItem)
                            CalendarView.CustomItems.BeginUpdate();
                        else
                            CalendarModel.BeginUpdate();

                        // Make the move

                        if (CalendarView.DoAppointmentViewChanging(SelectedItem, null, newDate,
                            newDate + ts, eViewOperation.AppointmentMove, IsNewCopyDrag) == false)
                        {
                            SelectedItem.StartTime = newDate;
                            SelectedItem.EndTime = newDate + ts;

                            NeedRecalcLayout = true;
                        }
                    }
                    finally
                    {
                        if (SelectedItem is CustomCalendarItem)
                            CalendarView.CustomItems.EndUpdate();
                        else
                            CalendarModel.EndUpdate();
                    }
                }
            }
        }

        #endregion

        #region CalendarItem MouseResize processing

        /// <summary>
        /// Processes CalendarItem left resizing
        /// </summary>
        /// <param name="col">Column</param>
        /// <param name="objArg"></param>
        private void ProcessItemLeftResize(int col, MouseEventArgs objArg)
        {
            DateTime date = (CalendarView.TimeLinePeriod == eTimeLinePeriod.Years) ?
                StartDate.AddYears(GetDeltaYears(col, true, objArg)) :
                StartDate.AddMinutes(GetDeltaMinutes(col, true, objArg));

            if (date < SelectedItem.EndTime && SelectedItem.StartTime != date)
                ResizeItem(date, SelectedItem.EndTime);
        }

        /// <summary>
        /// Processes CalendarItem right resizing
        /// </summary>
        /// <param name="col">Column</param>
        /// <param name="objArg"></param>
        private void ProcessItemRightResize(int col, MouseEventArgs objArg)
        {
            DateTime date = (CalendarView.TimeLinePeriod == eTimeLinePeriod.Years) ?
                StartDate.AddYears(GetDeltaYears(col, false, objArg)) :
                StartDate.AddMinutes(GetDeltaMinutes(col, false, objArg));

            if (date > SelectedItem.StartTime && SelectedItem.EndTime != date)
                ResizeItem(SelectedItem.StartTime, date);
        }

        /// <summary>
        /// Initiates the resize of the selected item
        /// </summary>
        /// <param name="startTime"></param>
        /// <param name="endTime"></param>
        private void ResizeItem(DateTime startTime, DateTime endTime)
        {
            // Let the user cancel the operation if desired

            if (CalendarView.DoAppointmentViewChanging(SelectedItem, null, startTime,
                endTime, eViewOperation.AppointmentResize, IsNewCopyDrag) == false)
            {
                SelectedItem.StartTime = startTime;
                SelectedItem.EndTime = endTime;

                NeedRecalcLayout = true;
            }
        }

        #endregion

        #region GetDeltaMinutes

        /// <summary>
        /// Gets the change from the last offset (in minutes)
        /// </summary>
        /// <param name="col">Column</param>
        /// <param name="left">Are we going left or right</param>
        /// <param name="objArg">MouseEventArgs</param>
        /// <returns>Change in mnutes</returns>
        private double GetDeltaMinutes(int col, bool left, MouseEventArgs objArg)
        {
            // Calculate our delta minutes

            Rectangle r = GetColRect(col);

            double dm = (objArg.Location.X - _LastPointOffset.X);

            dm += left ? _LastBounds.Left - r.Left
                       : _LastBounds.Right - r.Right;

            dm = BaseInterval * dm / ColumnWidth;

            // If the Alt key is not pressed, then round
            // our value off to the nearest column

            if ((Control.ModifierKeys & Keys.Alt) != Keys.Alt)
            {
                col += (int)(dm / BaseInterval);
                dm = 0;
            }

            dm += (col * BaseInterval);

            // Make sure we don't cross our day boundaries

            if (left == true)
            {
                if (dm < 0)
                    dm = 0;
            }
            else
            {
                dm += BaseInterval;
            }

            return (dm);
        }

        #endregion

        #region GetDeltaYears

        /// <summary>
        /// Gets the change from the last offset (in years)
        /// </summary>
        /// <param name="col">Column</param>
        /// <param name="left">Are we going left or right</param>
        /// <param name="objArg">MouseEventArgs</param>
        /// <returns>Change in years</returns>
        private int GetDeltaYears(int col, bool left, MouseEventArgs objArg)
        {
            // Calculate our delta minutes

            Rectangle r = GetColRect(col);

            int dm = (objArg.Location.X - _LastPointOffset.X);

            dm += left ? _LastBounds.Left - r.Left
                       : _LastBounds.Right - r.Right;

            dm = CalendarView.TimeLineInterval * dm / ColumnWidth;

            // If the Alt key is not pressed, then round
            // our value off to the nearest column

            if ((Control.ModifierKeys & Keys.Alt) != Keys.Alt)
            {
                col += dm / CalendarView.TimeLineInterval;
                dm = 0;
            }

            dm += (col * CalendarView.TimeLineInterval);

            // Make sure we don't cross our day boundaries

            if (left == true)
            {
                if (dm < 0)
                    dm = 0;
            }
            else
            {
                dm += CalendarView.TimeLineInterval;
            }

            return (dm);
        }

        #endregion

        #region View Scrolling support

        /// <summary>
        /// Routine to enable or disable view scrolling
        /// </summary>
        /// <param name="enable">true to enable</param>
        private void EnableViewScrolling(bool enable)
        {
            if (enable == true)
            {
                if (_ScrollViewTimer == null)
                {
                    _ScrollViewTimer = new Timer();

                    _ScrollViewTimer.Interval = 10;
                    _ScrollViewTimer.Tick += ScrollViewTimerTick;
                    _ScrollViewTimer.Start();
                }

                _ScrollDwell = 0;
            }
            else
            {
                CancelScrollTimer();
            }
        }

        /// <summary>
        /// Cancels the view scroll timer
        /// </summary>
        private void CancelScrollTimer()
        {
            // Dispose of our scroll timer

            if (_ScrollViewTimer != null)
            {
                _ScrollViewTimer.Stop();
                _ScrollViewTimer.Tick -= ScrollViewTimerTick;

                _ScrollViewTimer = null;
            }
        }

        /// <summary>
        /// Determines the amount to scroll (which is
        /// based loosely upon the delta magnitude)
        /// </summary>
        /// <param name="delta">Point delta</param>
        /// <returns>Scroll amount</returns>
        private int ScrollAmount(int delta)
        {
            _ScrollDwell++;

            int dx = Math.Abs(delta);
            int n = (dx < 16 ? 8 : dx < 32 ? 4 : 1);

            if (_ScrollDwell % n == 0)
                return (delta < 0 ? -1 : 1);

            return (0);
        }

        /// <summary>
        /// Handles view scroll timer ticks
        /// </summary>
        /// <param name="sender">object</param>
        /// <param name="e">EventArgs</param>
        void ScrollViewTimerTick(object sender, EventArgs e)
        {
            Control c = (Control)this.GetContainerControl(true);

            if (c != null)
            {
                // Calculate our delta

                Point pt = c.PointToClient(Cursor.Position);
                Rectangle r = ClientRect;

                int n = r.X + (ClientRect.Width / ColumnWidth) * ColumnWidth;

                int dx = (pt.X < r.Left) ? ScrollAmount(pt.X - r.Left) :
                    (pt.X >= n) ? ScrollAmount(pt.X - n) : 0;

                // Make sure we stay within our upper bounds

                if (dx < 0)
                {
                    if (CalendarView.TimeLineHScrollPanel.ScrollBar.Value + dx < 0)
                        dx = -CalendarView.TimeLineHScrollPanel.ScrollBar.Value;
                }
                else
                {
                    int maxValue = CalendarView.TimeLineHScrollPanel.ScrollBar.Maximum -
                        CalendarView.TimeLineHScrollPanel.ScrollBar.LargeChange;

                    if (CalendarView.TimeLineHScrollPanel.ScrollBar.Value + dx > maxValue)
                        dx = maxValue - CalendarView.TimeLineHScrollPanel.ScrollBar.Value;
                }

                // Scroll if necessary

                if (dx != 0)
                {
                    CalendarView.TimeLineHScrollPanel.ScrollBar.Value += dx;

                    if (PosWin != null)
                        PosWin.Hide();

                    InternalMouseMove(new
                        MouseEventArgs(MouseButtons.Left, 0, pt.X, pt.Y, 0));
                }
            }
        }

        #endregion

        #endregion

        #region GetPointItem

        /// <summary>
        /// Gets the item column at the given point
        /// </summary>
        /// <param name="pt">Point in question</param>
        /// <param name="col">[out] Column</param>
        /// <param name="partial">True if partial hits are ok</param>
        /// <returns>True if valid item</returns>
        private bool GetPointItem(Point pt, out int col, bool partial)
        {
            int start = -_HScrollPos / ColumnWidth;
            int end = start + ClientRect.Width / ColumnWidth;

            Rectangle r = GetColRect(start);

            for (int i = start; i <= end; i++)
            {
                if (r.Contains(pt) == true)
                {
                    col = i;

                    return (IsColVisible(r, partial));
                }

                r.X += ColumnWidth;
            }

            col = (pt.X < ClientRect.X) ? 0 : TimeLineColumnCount;

            return (false);
        }

        /// <summary>
        /// Determines if a given column is visible
        /// </summary>
        /// <param name="r">Display rectangle</param>
        /// <param name="partial">True if partial visibility is ok</param>
        /// <returns>True if visible</returns>
        private bool IsColVisible(Rectangle r, bool partial)
        {
            if (partial == true)
            {
                if (r.Right < ClientRect.Left)
                    return (false);

                if (r.Left > ClientRect.Right)
                    return (false);
            }
            else
            {
                if (r.Left < ClientRect.Left)
                    return (false);

                if (r.Right > ClientRect.Right)
                    return (false);
            }

            return (true);
        }

        #endregion

        #region PointInCondensedView

        /// <summary>
        /// Determines if the given point in in
        /// the CondensedView area
        /// </summary>
        /// <param name="pt"></param>
        /// <returns></returns>
        private bool PointInCondensedView(Point pt)
        {
            if (ShowCondensed == true)
                return (GetCondensedRect().Contains(pt));

            return (false);
        }

        #endregion

        #endregion

        #region InternalKeyDown

        #region InternalKeyDown

        /// <summary>
        /// Processes KeyDown events
        /// </summary>
        /// <param name="objArg"></param>
        public override void InternalKeyDown(KeyEventArgs objArg)
        {
            switch (objArg.KeyData)
            {
                case Keys.Up:
                case Keys.Up | Keys.Shift:
                case Keys.Up | Keys.Control:
                case Keys.Up | Keys.Control | Keys.Shift:
                    objArg.Handled = true;
                    break;

                case Keys.Down:
                case Keys.Down | Keys.Shift:
                case Keys.Down | Keys.Control:
                case Keys.Down | Keys.Control | Keys.Shift:
                    objArg.Handled = true;
                    break;

                case Keys.Left:
                case Keys.Left | Keys.Shift:
                case Keys.Left | Keys.Control:
                case Keys.Left | Keys.Control | Keys.Shift:
                    ProcessLeftRightKey(objArg, -1);
                    break;

                case Keys.Right:
                case Keys.Right | Keys.Shift:
                case Keys.Right | Keys.Control:
                case Keys.Right | Keys.Control | Keys.Shift:
                    ProcessLeftRightKey(objArg, 1);
                    break;

                case Keys.Home:
                case Keys.Home | Keys.Shift:
                case Keys.Home | Keys.Control:
                case Keys.Home | Keys.Control | Keys.Shift:
                    ProcessHomeKey(objArg);
                    break;

                case Keys.End:
                case Keys.End | Keys.Shift:
                case Keys.End | Keys.Control:
                case Keys.End | Keys.Control | Keys.Shift:
                    ProcessEndKey(objArg);
                    break;
            }
        }

        #endregion

        #region ProcessLeftRightKey

        /// <summary>
        /// Processes Left and Right Key events
        /// </summary>
        /// <param name="objArg"></param>
        /// <param name="dx"></param>
        protected virtual void ProcessLeftRightKey(KeyEventArgs objArg, int dx)
        {
            if (ValidDateSelection())
            {
// ReSharper disable PossibleInvalidOperationException

                DateTime startDate = CalendarView.DateSelectionStart.Value;
                DateTime endDate = CalendarView.DateSelectionEnd.Value;

                if (startDate.Equals(DateSelectionAnchor.Value) == true)
                    startDate = CalendarView.TimeLineAddInterval(endDate, -1);

// ReSharper restore PossibleInvalidOperationException

                startDate = CalendarView.TimeLineAddInterval(startDate, dx);
                endDate = CalendarView.TimeLineAddInterval(startDate, 1);

                DateTime viewStart = CalendarView.TimeLineViewScrollStartDate;
                DateTime viewEnd = CalendarView.TimeLineViewScrollEndDate;

                if (startDate < viewStart)
                {
                    CalendarView.TimeLineViewScrollStartDate = startDate;
                }
                else if (endDate > viewEnd)
                {
                    CalendarView.TimeLineViewScrollStartDate =
                        CalendarView.TimeLineAddInterval(CalendarView.TimeLineViewScrollStartDate, 1);
                }

                ExtendSelection(ref startDate, ref endDate);

                CalendarView.DateSelectionStart = startDate;
                CalendarView.DateSelectionEnd = endDate;
            }

            objArg.Handled = true;
        }

        #endregion

        #region ProcessHomeKey

        /// <summary>
        /// Handles Home key events
        /// </summary>
        /// <param name="objArg"></param>
        protected virtual void ProcessHomeKey(KeyEventArgs objArg)
        {
            DateTime startDate = CalendarView.TimeLineViewScrollStartDate;
            DateTime endDate = CalendarView.TimeLineAddInterval(startDate, 1);

            ExtendSelection(ref startDate, ref endDate);

            CalendarView.DateSelectionStart = startDate;
            CalendarView.DateSelectionEnd = endDate;

            SelectedItem = null;

            objArg.Handled = true;
        }

        #endregion

        #region ProcessEndKey

        /// <summary>
        /// Processes End key events
        /// </summary>
        /// <param name="objArg"></param>
        protected virtual void ProcessEndKey(KeyEventArgs objArg)
        {
            DateTime endDate = CalendarView.TimeLineViewScrollEndDate;
            DateTime startDate = CalendarView.TimeLineAddInterval(endDate, -1);

            ExtendSelection(ref startDate, ref endDate);

            CalendarView.DateSelectionStart = startDate;
            CalendarView.DateSelectionEnd = endDate;

            SelectedItem = null;

            objArg.Handled = true;
        }

        #endregion

        #endregion

        #region IDisposable Members

        protected override void Dispose(bool disposing)
        {
            if (disposing == true && IsDisposed == false)
            {
                ResetView();

                WorkBrush = null;
                OffWorkBrush = null;
                SelectedBrush = null;

                HookEvents(false);
            }

            base.Dispose(disposing);
        }

        #endregion
    }
}
#endif