View difference between Paste ID: b6HsgvXN and RdttF899

 // -----------------------------------------------------------------------
 // <copyright file="GanttChart.cs">
 // http://www.codeproject.com/Articles/20731/Gantt-Chart
 // <summary>
 // Adds an easy to use Gantt Chart to your application
 // Created by Adrian "Adagio" Grau
 // Version 0.55
 // </summary>
 // <remarks></remarks>
 // </copyright>
 // -----------------------------------------------------------------------
 
-    using System;
+using System;
-    using System.Collections.Generic;
+using System.Collections.Generic;
-    using System.Linq;
+using System.Linq;
-    using System.Text;
+using System.Text;
-    using System.Drawing.Drawing2D;
+using System.Drawing.Drawing2D;
-    using System.Drawing;
+using System.Drawing;
-    using System.Windows.Forms;
+using System.Windows.Forms;
 
 /// <summary>
-    /// TODO: Update summary.
+/// TODO: Update summary.
 /// </summary>
-    public class GanttChart : Control
+public class GanttChart : Control
 {
 
-        private MouseOverPart mouseHoverPart = MouseOverPart.Empty;
+    private MouseOverPart mouseHoverPart = MouseOverPart.Empty;
 
-        private int mouseHoverBarIndex = -1;
+    private int mouseHoverBarIndex = -1;
-        private List<ChartBarDate> bars = new List<ChartBarDate>();
+    private List<ChartBarDate> bars = new List<ChartBarDate>();
-        private System.DateTime headerFromDate;
+    private System.DateTime headerFromDate;
 
-        private System.DateTime headerToDate;
+    private System.DateTime headerToDate;
 
-        private int barIsChanging = -1;
+    private int barIsChanging = -1;
-        private int barStartRight = 20;
+    private int barStartRight = 20;
-        private int barStartLeft = 100;
+    private int barStartLeft = 100;
-        private int headerTimeStartTop = 30;
+    private int headerTimeStartTop = 30;
 
-        private List<Header> shownHeaderList;
+    private List<Header> shownHeaderList;
-        private int barStartTop = 50;
+    private int barStartTop = 50;
-        private int barHeight = 9;
+    private int barHeight = 9;
 
-        private int barSpace = 5;
+    private int barSpace = 5;
 
-        private int widthPerItem;
+    private int widthPerItem;
-        private System.DateTime _mouseOverColumnValue;
+    private System.DateTime _mouseOverColumnValue;
-        private string _mouseOverRowText = "";
+    private string _mouseOverRowText = "";
 
-        private object _mouseOverRowValue = null;
+    private object _mouseOverRowValue = null;
-        private Pen lineColor = Pens.Bisque;
+    private Pen lineColor = Pens.Bisque;
-        private Font dateTextFont = new Font("VERDANA", 8.0f, FontStyle.Regular, GraphicsUnit.Point);
+    private Font dateTextFont = new Font("VERDANA", 8.0f, FontStyle.Regular, GraphicsUnit.Point);
-        private Font timeTextFont = new Font("VERDANA", 8.0f, FontStyle.Regular, GraphicsUnit.Point);
+    private Font timeTextFont = new Font("VERDANA", 8.0f, FontStyle.Regular, GraphicsUnit.Point);
 
-        private Font rowTextFont = new Font("VERDANA", 8.0f, FontStyle.Regular, GraphicsUnit.Point);
+    private Font rowTextFont = new Font("VERDANA", 8.0f, FontStyle.Regular, GraphicsUnit.Point);
-        private System.Windows.Forms.ToolTip withEventsField_ToolTip = new System.Windows.Forms.ToolTip();
+    private System.Windows.Forms.ToolTip withEventsField_ToolTip = new System.Windows.Forms.ToolTip();
-        internal System.Windows.Forms.ToolTip ToolTip
+    internal System.Windows.Forms.ToolTip ToolTip
     {
-            get { return withEventsField_ToolTip; }
+        get { return withEventsField_ToolTip; }
-            set
+        set
         {
-                if (withEventsField_ToolTip != null)
+            if (withEventsField_ToolTip != null)
             {
-                    withEventsField_ToolTip.Draw -= ToolTipText_Draw;
+                withEventsField_ToolTip.Draw -= ToolTipText_Draw;
-                    withEventsField_ToolTip.Popup -= ToolTipText_Popup;
+                withEventsField_ToolTip.Popup -= ToolTipText_Popup;
             }
-                withEventsField_ToolTip = value;
+            withEventsField_ToolTip = value;
-                if (withEventsField_ToolTip != null)
+            if (withEventsField_ToolTip != null)
             {
-                    withEventsField_ToolTip.Draw += ToolTipText_Draw;
+                withEventsField_ToolTip.Draw += ToolTipText_Draw;
-                    withEventsField_ToolTip.Popup += ToolTipText_Popup;
+                withEventsField_ToolTip.Popup += ToolTipText_Popup;
             }
         }
 
     }
 
-        private bool _allowEditBarWithMouse = false;
+    private bool _allowEditBarWithMouse = false;
-        public event MouseDraggedEventHandler MouseDragged;
+    public event MouseDraggedEventHandler MouseDragged;
-        public delegate void MouseDraggedEventHandler(object sender, System.Windows.Forms.MouseEventArgs e);
+    public delegate void MouseDraggedEventHandler(object sender, System.Windows.Forms.MouseEventArgs e);
-        public event BarChangedEventHandler BarChanged;
+    public event BarChangedEventHandler BarChanged;
-        public delegate void BarChangedEventHandler(object sender, object barValue);
+    public delegate void BarChangedEventHandler(object sender, object barValue);
     public event BarChangingEventHandler BarChanging;
-        private Bitmap objBmp;
+    public delegate void BarChangingEventHandler(object sender, object barValue);
 
-        private Graphics objGraphics;
+    private Bitmap objBmp;
 
-        protected new bool DesignMode
+    private Graphics objGraphics;
 
-            get
+    protected new bool DesignMode
     {
-                if (base.DesignMode)
+        get
-                    return true;
+
             if (base.DesignMode)
-                return System.ComponentModel.LicenseManager.UsageMode == System.ComponentModel.LicenseUsageMode.Designtime;
+                return true;
 
             return System.ComponentModel.LicenseManager.UsageMode == System.ComponentModel.LicenseUsageMode.Designtime;
         }
-        #region "Public properties"
+    }
 
     #region "Public properties"
-        /// Sets to true if the user should be able to manually edit bars
+
     /// <summary>
     /// Sets to true if the user should be able to manually edit bars
     /// </summary>
     /// <value></value>
     /// <returns></returns>
-        public bool AllowManualEditBar
+    /// <remarks></remarks>
 
-            get { return _allowEditBarWithMouse; }
+    public bool AllowManualEditBar
-            set { _allowEditBarWithMouse = value; }
+
         get { return _allowEditBarWithMouse; }
         set { _allowEditBarWithMouse = value; }
     }
-        /// The start date/time of the chart
+
     /// <summary>
     /// The start date/time of the chart
     /// </summary>
     /// <value></value>
     /// <returns></returns>
-        public System.DateTime FromDate
+    /// <remarks></remarks>
 
-            get { return headerFromDate; }
+    public System.DateTime FromDate
-            set { headerFromDate = value; }
+
         get { return headerFromDate; }
         set { headerFromDate = value; }
     }
-        /// The end date/time of the chart
+
     /// <summary>
     /// The end date/time of the chart
     /// </summary>
     /// <value></value>
     /// <returns></returns>
-        public System.DateTime ToDate
+    /// <remarks></remarks>
 
-            get { return headerToDate; }
+    public System.DateTime ToDate
-            set { headerToDate = value; }
+
         get { return headerToDate; }
         set { headerToDate = value; }
     }
-        /// The text for the current row the mouse hovers above
+
     /// <summary>
     /// The text for the current row the mouse hovers above
     /// </summary>
     /// <value></value>
     /// <returns></returns>
-        public string MouseOverRowText
+    /// <remarks></remarks>
 
-            get { return _mouseOverRowText; }
+    public string MouseOverRowText
     {
         get { return _mouseOverRowText; }
     }
-        /// The value for the current bar the mouse hovers above
+
     /// <summary>
     /// The value for the current bar the mouse hovers above
     /// </summary>
     /// <value></value>
     /// <returns></returns>
-        public object MouseOverRowValue
+    /// <remarks></remarks>
 
-            get { return _mouseOverRowValue; }
+    public object MouseOverRowValue
     {
         get { return _mouseOverRowValue; }
     }
-        /// The date/time the mouse hovers above
+
     /// <summary>
     /// The date/time the mouse hovers above
     /// </summary>
     /// <value></value>
     /// <returns></returns>
-        public System.DateTime MouseOverColumnDate
+    /// <remarks></remarks>
 
-            get { return _mouseOverColumnValue; }
+    public System.DateTime MouseOverColumnDate
     {
         get { return _mouseOverColumnValue; }
     }
-        /// The color of the grid
+
     /// <summary>
     /// The color of the grid
     /// </summary>
     /// <value></value>
     /// <returns></returns>
-        public System.Drawing.Pen GridColor
+    /// <remarks></remarks>
 
-            get { return lineColor; }
+    public System.Drawing.Pen GridColor
-            set { lineColor = value; }
+
         get { return lineColor; }
         set { lineColor = value; }
     }
-        /// The font used for the row text
+
     /// <summary>
     /// The font used for the row text
     /// </summary>
     /// <value></value>
     /// <returns></returns>
-        public Font RowFont
+    /// <remarks></remarks>
 
-            get { return rowTextFont; }
+    public Font RowFont
-            set { rowTextFont = value; }
+
         get { return rowTextFont; }
         set { rowTextFont = value; }
     }
-        /// The font used for the "date" text in the columns
+
     /// <summary>
     /// The font used for the "date" text in the columns
     /// </summary>
     /// <value></value>
     /// <returns></returns>
-        public Font DateFont
+    /// <remarks></remarks>
 
-            get { return dateTextFont; }
+    public Font DateFont
-            set { dateTextFont = value; }
+
         get { return dateTextFont; }
         set { dateTextFont = value; }
     }
-        /// The font used for the "time" text in the colums)
+
     /// <summary>
     /// The font used for the "time" text in the colums)
     /// </summary>
     /// <value></value>
     /// <returns></returns>
-        public Font TimeFont
+    /// <remarks></remarks>
 
-            get { return timeTextFont; }
+    public Font TimeFont
-            set { timeTextFont = value; }
+
         get { return timeTextFont; }
         set { timeTextFont = value; }
-        #endregion
+    }
 
-        #region "Constructor"
+    #endregion
 
     #region "Constructor"
-        /// Default constructor
+
     /// <summary>
     /// Default constructor
     /// </summary>
-        public GanttChart()
+    /// <remarks></remarks>
 
-            if (!DesignMode)
+    public GanttChart()
     {
         MouseWheel += GanttChart_MouseWheel;
-                MouseWheel += GanttChart_MouseWheel;
+        MouseClick += GanttChart_Click;
-                MouseClick += GanttChart_Click;
+        MouseDragged += GanttChart_MouseDragged;
-                MouseDragged += GanttChart_MouseDragged;
+        MouseLeave += GanttChart_MouseLeave;
-                MouseLeave += GanttChart_MouseLeave;
+        MouseMove += GanttChart_MouseMove;
-                MouseMove += GanttChart_MouseMove;
+        ToolTip.AutoPopDelay = 15000;
-                ToolTip.AutoPopDelay = 15000;
+        ToolTip.InitialDelay = 250;
-                ToolTip.InitialDelay = 250;
+        ToolTip.OwnerDraw = true;
-                ToolTip.OwnerDraw = true;
+        objBmp = new Bitmap(1280, 1024, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
         objGraphics = Graphics.FromImage(objBmp);
-                objBmp = new Bitmap(1280, 1024, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
+        if (!DesignMode)
-                objGraphics = Graphics.FromImage(objBmp);
+
             // Flicker free drawing
-                // Flicker free drawing
+            this.SetStyle(ControlStyles.DoubleBuffer | ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint, true);
         }
-                this.SetStyle(ControlStyles.DoubleBuffer | ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint, true);
+
     }
 
     #endregion
 
-        #endregion
+    #region "Bars"
 
-        #region "Bars"
+    private void SetBarStartLeft(string rowText)
     {
-        private void SetBarStartLeft(string rowText)
+        Graphics gfx = this.CreateGraphics();
 
-            Graphics gfx = this.CreateGraphics();
+        int length = Convert.ToInt32(gfx.MeasureString(rowText, rowTextFont, 500).Width);
 
-            int length = Convert.ToInt32(gfx.MeasureString(rowText, rowTextFont, 500).Width);
+        if (length > barStartLeft)
         {
-            if (length > barStartLeft)
+            barStartLeft = length;
         }
-                barStartLeft = length;
+    }
 
     /// <summary>
     /// Adds a bar to the list
     /// </summary>
-        /// Adds a bar to the list
+    /// <param name="rowText">Text for the row</param>
     /// <param name="barValue">Value for the row</param>
-        /// <param name="rowText">Text for the row</param>
+    /// <param name="fromTime">The date/time the bar starts</param>
-        /// <param name="barValue">Value for the row</param>
+    /// <param name="toTime">The date/time the bar ends</param>
-        /// <param name="fromTime">The date/time the bar starts</param>
+    /// <param name="color">The color of the bar</param>
-        /// <param name="toTime">The date/time the bar ends</param>
+    /// <param name="hoverColor">The hover color of the bar</param>
-        /// <param name="color">The color of the bar</param>
+    /// <param name="rowIndex">The rowindex of the bar (useful if you want several bars on the same row)</param>
-        /// <param name="hoverColor">The hover color of the bar</param>
+    /// <remarks></remarks>
-        /// <param name="rowIndex">The rowindex of the bar (useful if you want several bars on the same row)</param>
+
     public void AddChartBar(string rowText, object barValue, System.DateTime fromTime, System.DateTime toTime, Color color, Color hoverColor, int rowIndex)
     {
-        public void AddChartBar(string rowText, object barValue, System.DateTime fromTime, System.DateTime toTime, Color color, Color hoverColor, int rowIndex)
+        ChartBarDate bar = new ChartBarDate();
         bar.Text = rowText;
-            ChartBarDate bar = new ChartBarDate();
+        bar.Value = barValue;
-            bar.Text = rowText;
+        bar.StartValue = fromTime;
-            bar.Value = barValue;
+        bar.EndValue = toTime;
-            bar.StartValue = fromTime;
+        bar.Color = color;
-            bar.EndValue = toTime;
+        bar.HoverColor = hoverColor;
-            bar.Color = color;
+        bar.RowIndex = rowIndex;
-            bar.HoverColor = hoverColor;
+        bars.Add(bar);
-            bar.RowIndex = rowIndex;
+
-            bars.Add(bar);
+        SetBarStartLeft(rowText);
     }
-            SetBarStartLeft(rowText);
+
     /// <summary>
     /// Adds a bar to the list
     /// </summary>
-        /// Adds a bar to the list
+    /// <param name="rowText">Text for the row</param>
     /// <param name="barValue">Value for the row</param>
-        /// <param name="rowText">Text for the row</param>
+    /// <param name="fromTime">The date/time the bar starts</param>
-        /// <param name="barValue">Value for the row</param>
+    /// <param name="toTime">The date/time the bar ends</param>
-        /// <param name="fromTime">The date/time the bar starts</param>
+    /// <param name="color">The color of the bar</param>
-        /// <param name="toTime">The date/time the bar ends</param>
+    /// <param name="hoverColor">The hover color of the bar</param>
-        /// <param name="color">The color of the bar</param>
+    /// <param name="rowIndex">The rowindex of the bar (useful if you want several bars on the same row)</param>
-        /// <param name="hoverColor">The hover color of the bar</param>
+    /// <param name="hideFromMouseMove">If you want to "hide" the bar from mousemove event</param>
-        /// <param name="rowIndex">The rowindex of the bar (useful if you want several bars on the same row)</param>
+    /// <remarks></remarks>
-        /// <param name="hideFromMouseMove">If you want to "hide" the bar from mousemove event</param>
+
     public void AddChartBar(string rowText, object barValue, System.DateTime fromTime, System.DateTime toTime, Color color, Color hoverColor, int rowIndex, bool hideFromMouseMove)
     {
-        public void AddChartBar(string rowText, object barValue, System.DateTime fromTime, System.DateTime toTime, Color color, Color hoverColor, int rowIndex, bool hideFromMouseMove)
+        ChartBarDate bar = new ChartBarDate();
         bar.Text = rowText;
-            ChartBarDate bar = new ChartBarDate();
+        bar.Value = barValue;
-            bar.Text = rowText;
+        bar.StartValue = fromTime;
-            bar.Value = barValue;
+        bar.EndValue = toTime;
-            bar.StartValue = fromTime;
+        bar.Color = color;
-            bar.EndValue = toTime;
+        bar.HoverColor = hoverColor;
-            bar.Color = color;
+        bar.RowIndex = rowIndex;
-            bar.HoverColor = hoverColor;
+        bar.HideFromMouseMove = hideFromMouseMove;
-            bar.RowIndex = rowIndex;
+        bars.Add(bar);
-            bar.HideFromMouseMove = hideFromMouseMove;
+
-            bars.Add(bar);
+        SetBarStartLeft(rowText);
     }
-            SetBarStartLeft(rowText);
+
     /// <summary>
     /// Gets the next index
     /// </summary>
-        /// Gets the next index
+    /// <param name="rowText"></param>
     /// <returns></returns>
-        /// <param name="rowText"></param>
+    /// <remarks></remarks>
 
     public int GetIndexChartBar(string rowText)
     {
-        public int GetIndexChartBar(string rowText)
+        int index = -1;
 
-            int index = -1;
+        foreach (ChartBarDate bar in bars)
         {
             if (bar.Text.Equals(rowText) == true)
             {
-                if (bar.Text.Equals(rowText) == true)
+                return bar.RowIndex;
             }
-                    return bar.RowIndex;
+            if (bar.RowIndex > index)
             {
-                if (bar.RowIndex > index)
+
             }
-                    index = bar.RowIndex;
+
 
         return index + 1;
     }
-            return index + 1;
+
     /// <summary>
     /// Removes all bars from list
     /// </summary>
-        /// Removes all bars from list
+    /// <remarks></remarks>
 
     public void RemoveBars()
     {
-        public void RemoveBars()
+        bars = new List<ChartBarDate>();
 
-            bars = new List<ChartBarDate>();
+        barStartLeft = 100;
     }
-            barStartLeft = 100;
+
     #endregion
 
-        #endregion
+    #region "Draw"
 
-        #region "Draw"
+
     /// Redraws the Gantt chart
     /// </summary>
-        /// Redraws the Gantt chart
+    /// <remarks></remarks>
 
     public void PaintChart()
     {
-        public void PaintChart()
+        this.Invalidate();
     }
-            this.Invalidate();
+
     /// <summary>
     /// Redraws the Gantt chart
     /// </summary>
-        /// Redraws the Gantt chart
+    /// <param name="gfx"></param>
     /// <remarks></remarks>
-        /// <param name="gfx"></param>
+
     private void PaintChart(Graphics gfx)
     {
-        private void PaintChart(Graphics gfx)
+        gfx.Clear(this.BackColor);
 
-            gfx.Clear(this.BackColor);
+        if (headerFromDate == null | headerToDate == null)
             return;
-            if (headerFromDate == null | headerToDate == null)
+
         DrawScrollBar(gfx);
         DrawHeader(gfx, null);
-            DrawScrollBar(gfx);
+        DrawNetHorizontal(gfx);
-            DrawHeader(gfx, null);
+        DrawNetVertical(gfx);
-            DrawNetHorizontal(gfx);
+        DrawBars(gfx);
-            DrawNetVertical(gfx);
+
-            DrawBars(gfx);
+        objBmp = new Bitmap(this.Width - barStartRight, lastLineStop, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
         objGraphics = Graphics.FromImage(objBmp);
     }
 
     /// <summary>
     /// Redraws the Gantt chart
     /// </summary>
-        /// Redraws the Gantt chart
+    /// <param name="pe"></param>
     /// <remarks></remarks>
-        /// <param name="pe"></param>
+
     protected override void OnPaint(System.Windows.Forms.PaintEventArgs pe)
     {
-        protected override void OnPaint(System.Windows.Forms.PaintEventArgs pe)
+        base.OnPaint(pe);
         if (!DesignMode)
-            base.OnPaint(pe);
+
-            if (!DesignMode)
+            PaintChart(pe.Graphics);
         }
-                PaintChart(pe.Graphics);
+    }
 
     /// <summary>
     /// Draws the list of headers. Automatically shows which headers to draw, based on the width of the Gantt Chart
     /// </summary>
-        /// Draws the list of headers. Automatically shows which headers to draw, based on the width of the Gantt Chart
+    /// <param name="gfx"></param>
     /// <param name="headerList"></param>
-        /// <param name="gfx"></param>
+    /// <remarks></remarks>
-        /// <param name="headerList"></param>
+
     private void DrawHeader(Graphics gfx, List<Header> headerList)
     {
-        private void DrawHeader(Graphics gfx, List<Header> headerList)
+        if (headerList == null)
         {
-            if (headerList == null)
+            headerList = GetFullHeaderList();
         }
-                headerList = GetFullHeaderList();
+
         if (headerList.Count == 0)
             return;
-            if (headerList.Count == 0)
+
         dynamic availableWidth = this.Width - 10 - barStartLeft - barStartRight;
         widthPerItem = availableWidth / headerList.Count;
-            dynamic availableWidth = this.Width - 10 - barStartLeft - barStartRight;
+
-            widthPerItem = availableWidth / headerList.Count;
+        if (widthPerItem < 40)
         {
-            if (widthPerItem < 40)
+            List<Header> newHeaderList = new List<Header>();
 
-                List<Header> newHeaderList = new List<Header>();
+            bool showNext = true;
 
-                bool showNext = true;
+            // If there's not enough room for all headers remove 50%
 
-                // If there's not enough room for all headers remove 50%
+
             {
-                foreach (Header header in headerList)
+                if (showNext == true)
                 {
-                    if (showNext == true)
+                    newHeaderList.Add(header);
                     showNext = false;
-                        newHeaderList.Add(header);
+
-                        showNext = false;
+
                 {
-                    else
+                    showNext = true;
                 }
-                        showNext = true;
+
 
             DrawHeader(gfx, newHeaderList);
             return;
-                DrawHeader(gfx, newHeaderList);
+
 
         int index = 0;
         int headerStartPosition = -1;
         Header lastHeader = null;
-            int headerStartPosition = -1;
+
-            Header lastHeader = null;
+        foreach (Header header in headerList)
         {
             int startPos = barStartLeft + (index * widthPerItem);
             bool showDateHeader = false;
-                int startPos = barStartLeft + (index * widthPerItem);
+
-                bool showDateHeader = false;
+            header.StartLocation = startPos;
 
-                header.StartLocation = startPos;
+            // Checks whether to show the date or not
 
-                // Checks whether to show the date or not
+            if (lastHeader == null)
             {
-                if (lastHeader == null)
+                showDateHeader = true;
             }
-                    showDateHeader = true;
+            else if (header.Time.Hour < lastHeader.Time.Hour)
             {
-                else if (header.Time.Hour < lastHeader.Time.Hour)
+                showDateHeader = true;
             }
-                    showDateHeader = true;
+            else if (header.Time.Minute == lastHeader.Time.Minute)
             {
-                else if (header.Time.Minute == lastHeader.Time.Minute)
+                showDateHeader = true;
             }
-                    showDateHeader = true;
+
             // Show date
 
-                // Show date
+            if (showDateHeader == true)
             {
-                if (showDateHeader == true)
+                string str = "";
 
-                    string str = "";
+                if (header.HeaderTextInsteadOfTime.Length > 0)
                 {
-                    if (header.HeaderTextInsteadOfTime.Length > 0)
+                    str = header.HeaderTextInsteadOfTime;
                 }
-                        str = header.HeaderTextInsteadOfTime;
+
                 {
-                    else
+                    str = header.Time.ToString("d-MMM");
                 }
-                        str = header.Time.ToString("d-MMM");
+                gfx.DrawString(str, dateTextFont, Brushes.Black, startPos, 0);
             }
-                    gfx.DrawString(str, dateTextFont, Brushes.Black, startPos, 0);
+
             // Show time
 
-                // Show time
+            gfx.DrawString(header.HeaderText, timeTextFont, Brushes.Black, startPos, headerTimeStartTop);
             index += 1;
-                gfx.DrawString(header.HeaderText, timeTextFont, Brushes.Black, startPos, headerTimeStartTop);
+
             lastHeader = header;
         }
-                lastHeader = header;
+
         shownHeaderList = headerList;
         widthPerItem = (this.Width - 10 - barStartLeft - barStartRight) / shownHeaderList.Count;
-            shownHeaderList = headerList;
+    }
-            widthPerItem = (this.Width - 10 - barStartLeft - barStartRight) / shownHeaderList.Count;
+
     /// <summary>
     /// Draws the bars
     /// </summary>
-        /// Draws the bars
+    /// <param name="grfx"></param>
     /// <remarks></remarks>
-        /// <param name="grfx"></param>
+
     private void DrawBars(Graphics grfx, bool ignoreScrollAndMousePosition = false)
     {
-        private void DrawBars(Graphics grfx, bool ignoreScrollAndMousePosition = false)
+        if (shownHeaderList == null)
             return;
-            if (shownHeaderList == null)
+        if (shownHeaderList.Count == 0)
             return;
-            if (shownHeaderList.Count == 0)
+
         int index = 0;
 
         // Finds pixels per minute
 
-            // Finds pixels per minute
+        TimeSpan timeBetween = shownHeaderList[1].Time - shownHeaderList[0].Time;
         int minutesBetween = Convert.ToInt32(timeBetween.TotalMinutes);
-            TimeSpan timeBetween = shownHeaderList[1].Time - shownHeaderList[0].Time;
+        //(timeBetween.Days * 1440) + (timeBetween.Hours * 60) + timeBetween.Minutes
-            int minutesBetween = Convert.ToInt32(timeBetween.TotalMinutes);
+        dynamic widthBetween = (shownHeaderList[1].StartLocation - shownHeaderList[0].StartLocation);
-            //(timeBetween.Days * 1440) + (timeBetween.Hours * 60) + timeBetween.Minutes
+        decimal perMinute = Convert.ToDecimal(widthBetween) / Convert.ToDecimal(minutesBetween);
-            dynamic widthBetween = (shownHeaderList[1].StartLocation - shownHeaderList[0].StartLocation);
+
-            decimal perMinute = widthBetween / minutesBetween;
+        // Draws each bar
 
-            // Draws each bar
+        foreach (ChartBarDate bar in bars)
         {
             index = bar.RowIndex;
 
             int startLocation = 0;
             int width = 0;
-                int startLocation = 0;
+            int startMinutes = 0;
-                int width = 0;
+            // Number of minutes from start of the gantt chart
-                int startMinutes = 0;
+            TimeSpan startTimeSpan = default(TimeSpan);
-                // Number of minutes from start of the gantt chart
+            int lengthMinutes = 0;
-                TimeSpan startTimeSpan = default(TimeSpan);
+            // Number of minutes from bar start to bar end
-                int lengthMinutes = 0;
+            TimeSpan lengthTimeSpan = default(TimeSpan);
-                // Number of minutes from bar start to bar end
+
-                TimeSpan lengthTimeSpan = default(TimeSpan);
+            int scrollPos = 0;
 
-                int scrollPos = 0;
+            if (ignoreScrollAndMousePosition == false)
             {
-                if (ignoreScrollAndMousePosition == false)
+                scrollPos = scrollPosition;
             }
-                    scrollPos = scrollPosition;
+
             // Calculates where the bar should be located
 
-                // Calculates where the bar should be located
+            startTimeSpan = bar.StartValue - FromDate;
             startMinutes = (startTimeSpan.Days * 1440) + (startTimeSpan.Hours * 60) + startTimeSpan.Minutes;
-                startTimeSpan = bar.StartValue - FromDate;
+
-                startMinutes = (startTimeSpan.Days * 1440) + (startTimeSpan.Hours * 60) + startTimeSpan.Minutes;
+            startLocation = Convert.ToInt32(perMinute * startMinutes);
 
-                startLocation = Convert.ToInt32(perMinute * startMinutes);
+            System.DateTime endValue = bar.EndValue;
 
-                System.DateTime endValue = bar.EndValue;
+            if (endValue == null)
             {
-                if (endValue == null)
+                endValue = System.DateTime.Now;
             }
-                    endValue = System.DateTime.Now;
+
             lengthTimeSpan = endValue - bar.StartValue;
             lengthMinutes = (lengthTimeSpan.Days * 1440) + (lengthTimeSpan.Hours * 60) + lengthTimeSpan.Minutes;
-                lengthTimeSpan = endValue - bar.StartValue;
+
-                lengthMinutes = (lengthTimeSpan.Days * 1440) + (lengthTimeSpan.Hours * 60) + lengthTimeSpan.Minutes;
+            width = Convert.ToInt32(perMinute * lengthMinutes);
 
-                width = Convert.ToInt32(perMinute * lengthMinutes);
+            int a = barStartLeft + startLocation;
             int b = barStartTop + (barHeight * (index - scrollPos)) + (barSpace * (index - scrollPos)) + 2;
-                int a = barStartLeft + startLocation;
+            int c = width;
-                int b = barStartTop + (barHeight * (index - scrollPos)) + (barSpace * (index - scrollPos)) + 2;
+            int d = barHeight;
-                int c = width;
+
-                int d = barHeight;
+            if (c == 0)
                 c = 1;
-                if (c == 0)
+
-                    c = 1;
+            // Stops a bar from going into the row-text area
 
-                // Stops a bar from going into the row-text area
+            if (a - barStartLeft < 0)
             {
-                if (a - barStartLeft < 0)
+                a = barStartLeft;
             }
-                    a = barStartLeft;
+
             System.Drawing.Color color = default(System.Drawing.Color);
 
-                System.Drawing.Color color = default(System.Drawing.Color);
+            // If mouse is over bar, set the color to be hovercolor
 
-                // If mouse is over bar, set the color to be hovercolor
+            if (MouseOverRowText == bar.Text & bar.StartValue <= _mouseOverColumnValue & bar.EndValue >= _mouseOverColumnValue)
             {
-                if (MouseOverRowText == bar.Text & bar.StartValue <= _mouseOverColumnValue & bar.EndValue >= _mouseOverColumnValue)
+                color = bar.HoverColor;
             }
-                    color = bar.HoverColor;
+
             {
                 color = bar.Color;
             }
-                    color = bar.Color;
+
             // Set the location for the graphics
 
-                // Set the location for the graphics
+            bar.TopLocation.Left = new Point(a, b);
             bar.TopLocation.Right = new Point(a + c, b);
-                bar.TopLocation.Left = new Point(a, b);
+            bar.BottomLocation.Left = new Point(a, b + d);
-                bar.TopLocation.Right = new Point(a + c, b);
+            bar.BottomLocation.Right = new Point(a, b + d);
-                bar.BottomLocation.Left = new Point(a, b + d);
+
-                bar.BottomLocation.Right = new Point(a, b + d);
+            LinearGradientBrush obBrush = null;
             Rectangle obRect = new Rectangle(a, b, c, d);
-                LinearGradientBrush obBrush = null;
+
-                Rectangle obRect = new Rectangle(a, b, c, d);
+            if (bar.StartValue != null & endValue != null)
             {
-                if (bar.StartValue != null & endValue != null)
+
                 if ((index >= scrollPos & index < barsViewable + scrollPos) | ignoreScrollAndMousePosition == true)
                 {
-                    if ((index >= scrollPos & index < barsViewable + scrollPos) | ignoreScrollAndMousePosition == true)
+                    // Makes the bar gradient
 
-                        // Makes the bar gradient
+                    obBrush = new LinearGradientBrush(obRect, color, Color.Gray, LinearGradientMode.Vertical);
 
-                        obBrush = new LinearGradientBrush(obRect, color, Color.Gray, LinearGradientMode.Vertical);
+                    // Draws the bar
 
-                        // Draws the bar
+                    grfx.DrawRectangle(Pens.Black, obRect);
                     grfx.FillRectangle(obBrush, obRect);
-                        grfx.DrawRectangle(Pens.Black, obRect);
+
-                        grfx.FillRectangle(obBrush, obRect);
+                    // Draws the rowtext
 
-                        // Draws the rowtext
+                    grfx.DrawString(bar.Text, rowTextFont, Brushes.Black, 0, barStartTop + (barHeight * (index - scrollPos)) + (barSpace * (index - scrollPos)));
 
-                        grfx.DrawString(bar.Text, rowTextFont, Brushes.Black, 0, barStartTop + (barHeight * (index - scrollPos)) + (barSpace * (index - scrollPos)));
+                    obBrush = null;
                     //obRect = null;
-                        obBrush = null;
+                    //obRect.TryDispose();
-                        //obRect = null;
+                    obBrush = null;
-                        //obRect.TryDispose();
+
-                        obBrush = null;
+
 
             //color = null;
             //color.TryDispose();
-                //color = null;
+
-                //color.TryDispose();
+    }
 
     /// <summary>
     /// Draws the vertical lines
     /// </summary>
-        /// Draws the vertical lines
+    /// <param name="grfx"></param>
     /// <remarks></remarks>
-        /// <param name="grfx"></param>
+
     public void DrawNetVertical(Graphics grfx)
     {
-        public void DrawNetVertical(Graphics grfx)
+        if (shownHeaderList == null)
             return;
-            if (shownHeaderList == null)
+        if (shownHeaderList.Count == 0)
             return;
-            if (shownHeaderList.Count == 0)
+
         int index = 0;
         int availableWidth = this.Width - 10 - barStartLeft - barStartRight;
         Header lastHeader = null;
-            int availableWidth = this.Width - 10 - barStartLeft - barStartRight;
+
-            Header lastHeader = null;
+        foreach (Header header in shownHeaderList)
         {
-            foreach (Header header in shownHeaderList)
+            int headerLocationY = 0;
 
-                int headerLocationY = 0;
+            if (lastHeader == null)
             {
-                if (lastHeader == null)
+                headerLocationY = 0;
             }
-                    headerLocationY = 0;
+            else if (header.Time.Hour < lastHeader.Time.Hour)
             {
-                else if (header.Time.Hour < lastHeader.Time.Hour)
+                headerLocationY = 0;
             }
-                    headerLocationY = 0;
+
             {
                 headerLocationY = headerTimeStartTop;
             }
-                    headerLocationY = headerTimeStartTop;
+
             grfx.DrawLine(Pens.Bisque, barStartLeft + (index * widthPerItem), headerLocationY, barStartLeft + (index * widthPerItem), lastLineStop);
             index += 1;
-                grfx.DrawLine(Pens.Bisque, barStartLeft + (index * widthPerItem), headerLocationY, barStartLeft + (index * widthPerItem), lastLineStop);
+
             lastHeader = header;
         }
-                lastHeader = header;
+
         grfx.DrawLine(lineColor, barStartLeft + (index * widthPerItem), headerTimeStartTop, barStartLeft + (index * widthPerItem), lastLineStop);
     }
-            grfx.DrawLine(lineColor, barStartLeft + (index * widthPerItem), headerTimeStartTop, barStartLeft + (index * widthPerItem), lastLineStop);
+
     /// <summary>
     /// Draws the horizontal lines
     /// </summary>
-        /// Draws the horizontal lines
+    /// <param name="grfx"></param>
     /// <remarks></remarks>
-        /// <param name="grfx"></param>
+
     public void DrawNetHorizontal(Graphics grfx)
     {
-        public void DrawNetHorizontal(Graphics grfx)
+        if (shownHeaderList == null)
             return;
-            if (shownHeaderList == null)
+        if (shownHeaderList.Count == 0)
             return;
-            if (shownHeaderList.Count == 0)
+
         int index = 0;
         int width = (widthPerItem * shownHeaderList.Count) + barStartLeft;
 
-            int width = (widthPerItem * shownHeaderList.Count) + barStartLeft;
+        // Last used index. Hopefully nobody will make a row named QQQ :o)
         for (index = 0; index <= GetIndexChartBar("QQQQQQ"); index++)
-            // Last used index. Hopefully nobody will make a row named QQQ :o)
+
-            for (index = 0; index <= GetIndexChartBar("QQQQQQ"); index++)
+
             {
-                foreach (ChartBarDate bar in bars)
+                grfx.DrawLine(lineColor, 0, barStartTop + (barHeight * index) + (barSpace * index), width, barStartTop + (barHeight * index) + (barSpace * index));
             }
-                    grfx.DrawLine(lineColor, 0, barStartTop + (barHeight * index) + (barSpace * index), width, barStartTop + (barHeight * index) + (barSpace * index));
+
 
         lastLineStop = barStartTop + (barHeight * (index - 1)) + (barSpace * (index - 1));
     }
-            lastLineStop = barStartTop + (barHeight * (index - 1)) + (barSpace * (index - 1));
+
     // This is the position (in pixels, from top) of the last line. Used for drawing lines
 
-        // This is the position (in pixels, from top) of the last line. Used for drawing lines
+
     private int lastLineStop = 0;
     #endregion
-        private int lastLineStop = 0;
+
-        #endregion
+    #region "Header list"
 
-        #region "Header list"
+
     /// Gets the full header list, consisting of hours between the two dates set
     /// </summary>
-        /// Gets the full header list, consisting of hours between the two dates set
+    /// <returns></returns>
     /// <remarks></remarks>
 
     private List<Header> GetFullHeaderList()
     {
-        private List<Header> GetFullHeaderList()
+        List<Header> result = new List<Header>();
         System.DateTime newFromTime = new System.DateTime(FromDate.Year, FromDate.Month, FromDate.Day);
-            List<Header> result = new List<Header>();
+        string item = null;
-            System.DateTime newFromTime = new System.DateTime(FromDate.Year, FromDate.Month, FromDate.Day);
+
-            string item = null;
+        TimeSpan interval = ToDate - FromDate;
 
-            TimeSpan interval = ToDate - FromDate;
+        if (interval.TotalDays < 1)
         {
-            if (interval.TotalDays < 1)
+            var _with1 = newFromTime;
             newFromTime = _with1.AddHours(FromDate.Hour);
-                var _with1 = newFromTime;
+
-                newFromTime = _with1.AddHours(FromDate.Hour);
+            if (headerFromDate.Minute < 59 & headerFromDate.Minute > 29)
             {
-                if (headerFromDate.Minute < 59 & headerFromDate.Minute > 29)
+                newFromTime = _with1.AddMinutes(30);
             }
-                    newFromTime = _with1.AddMinutes(30);
+
             {
                 newFromTime = _with1.AddMinutes(0);
             }
-                    newFromTime = _with1.AddMinutes(0);
+
             while (newFromTime <= ToDate)
             {
-                while (newFromTime <= ToDate)
+                item = newFromTime.Hour + ":";
 
-                    item = newFromTime.Hour + ":";
+                if (newFromTime.Minute < 10)
                 {
-                    if (newFromTime.Minute < 10)
+                    item += "0" + newFromTime.Minute;
                 }
-                        item += "0" + newFromTime.Minute;
+
                 {
-                    else
+                    item += "" + newFromTime.Minute;
                 }
-                        item += "" + newFromTime.Minute;
+
                 Header header = new Header();
 
-                    Header header = new Header();
+                header.HeaderText = item;
                 header.HeaderTextInsteadOfTime = "";
-                    header.HeaderText = item;
+                header.Time = new System.DateTime(newFromTime.Year, newFromTime.Month, newFromTime.Day, newFromTime.Hour, newFromTime.Minute, 0);
-                    header.HeaderTextInsteadOfTime = "";
+                result.Add(header);
-                    header.Time = new System.DateTime(newFromTime.Year, newFromTime.Month, newFromTime.Day, newFromTime.Hour, newFromTime.Minute, 0);
+
-                    result.Add(header);
+                newFromTime = newFromTime.AddMinutes(5);
                 // The minimum interval of time between the headers
-                    newFromTime = newFromTime.AddMinutes(5);
+
-                    // The minimum interval of time between the headers
+
         else if (interval.TotalDays < 60)
         {
-            else if (interval.TotalDays < 60)
+            while (newFromTime <= ToDate)
             {
-                while (newFromTime <= ToDate)
+                Header header = new Header();
 
-                    Header header = new Header();
+                header.HeaderText = "";
                 header.HeaderTextInsteadOfTime = "";
-                    header.HeaderText = "";
+                header.Time = new System.DateTime(newFromTime.Year, newFromTime.Month, newFromTime.Day, 0, 0, 0);
-                    header.HeaderTextInsteadOfTime = "";
+                result.Add(header);
-                    header.Time = new System.DateTime(newFromTime.Year, newFromTime.Month, newFromTime.Day, 0, 0, 0);
+
-                    result.Add(header);
+                newFromTime = newFromTime.AddDays(1);
                 // The minimum interval of time between the headers
-                    newFromTime = newFromTime.AddDays(1);
+
-                    // The minimum interval of time between the headers
+
         else
         {
             while (newFromTime <= ToDate)
             {
-                while (newFromTime <= ToDate)
+                Header header = new Header();
 
-                    Header header = new Header();
+                header.HeaderText = "";
                 header.Time = new System.DateTime(newFromTime.Year, newFromTime.Month, newFromTime.Day, 0, 0, 0);
-                    header.HeaderText = "";
+                header.HeaderTextInsteadOfTime = newFromTime.ToString("MMM");
-                    header.Time = new System.DateTime(newFromTime.Year, newFromTime.Month, newFromTime.Day, 0, 0, 0);
+                result.Add(header);
-                    header.HeaderTextInsteadOfTime = newFromTime.ToString("MMM");
+
-                    result.Add(header);
+                newFromTime = newFromTime.AddMonths(1);
                 // The minimum interval of time between the headers
-                    newFromTime = newFromTime.AddMonths(1);
+
-                    // The minimum interval of time between the headers
+
 
         return result;
     }
-            return result;
+
     #endregion
 
-        #endregion
+    #region "Mouse Move"
 
-        #region "Mouse Move"
+
     /// Finds the current row and column based on mouse position
     /// </summary>
-        /// Finds the current row and column based on mouse position
+    /// <param name="sender"></param>
     /// <param name="e"></param>
-        /// <param name="sender"></param>
+    /// <remarks></remarks>
-        /// <param name="e"></param>
+
     private void GanttChart_MouseMove(System.Object sender, System.Windows.Forms.MouseEventArgs e)
     {
-        private void GanttChart_MouseMove(System.Object sender, System.Windows.Forms.MouseEventArgs e)
+        if (shownHeaderList == null)
             return;
-            if (shownHeaderList == null)
+        if (shownHeaderList.Count == 0)
             return;
-            if (shownHeaderList.Count == 0)
+
         if (e.Button != System.Windows.Forms.MouseButtons.Left)
         {
-            if (e.Button != System.Windows.Forms.MouseButtons.Left)
+
 
-                mouseHoverPart = MouseOverPart.Empty;
+            // If bar has changed manually, but left mouse button is no longer pressed the BarChanged event will be raised
 
-                // If bar has changed manually, but left mouse button is no longer pressed the BarChanged event will be raised
+
             {
-                if (AllowManualEditBar == true)
+                if (barIsChanging >= 0)
                 {
-                    if (barIsChanging >= 0)
+                    if (BarChanged != null)
                     {
-                        if (BarChanged != null)
+                        BarChanged(this, bars[barIsChanging].Value);
                     }
-                            BarChanged(this, bars[barIsChanging].Value);
+                    barIsChanging = -1;
                 }
-                        barIsChanging = -1;
+
         }
         else if (e.Button == System.Windows.Forms.MouseButtons.Left)
         {
             if (AllowManualEditBar == true)
-            mouseHoverBarIndex = -1;
+
                 if (barIsChanging >= 0)
                 {
                     if (BarChanging != null)
                     {
                         BarChanging(this, bars[barIsChanging].Value);
-            // Finds pixels per minute
+
                 }
-            TimeSpan timeBetween = shownHeaderList[1].Time - shownHeaderList[0].Time;
+
-            int minutesBetween = (timeBetween.Days * 1440) + (timeBetween.Hours * 60) + timeBetween.Minutes;
+
-            dynamic widthBetween = (shownHeaderList[1].StartLocation - shownHeaderList[0].StartLocation);
+
-            decimal perMinute = widthBetween / minutesBetween;
+        mouseHoverBarIndex = -1;
 
-            // Finds the time at mousepointer
+        Point LocalMousePosition = default(Point);
 
-            int minutesAtCursor = 0;
+        LocalMousePosition = this.PointToClient(Cursor.Position);
 
-            if (LocalMousePosition.X > barStartLeft && perMinute > 0)
+        // Finds pixels per minute
 
-                minutesAtCursor = Convert.ToInt32((LocalMousePosition.X - barStartLeft) / perMinute);
+        TimeSpan timeBetween = shownHeaderList[1].Time - shownHeaderList[0].Time;
-                _mouseOverColumnValue = FromDate.AddMinutes(minutesAtCursor);
+        int minutesBetween = (timeBetween.Days * 1440) + (timeBetween.Hours * 60) + timeBetween.Minutes;
         dynamic widthBetween = (shownHeaderList[1].StartLocation - shownHeaderList[0].StartLocation);
         decimal perMinute = Convert.ToDecimal(widthBetween) / Convert.ToDecimal(minutesBetween);
 
-                //_mouseOverColumnValue.TryDispose();
+        // Finds the time at mousepointer
 
         int minutesAtCursor = 0;
-            // Finds the row at mousepointer
+
         if (LocalMousePosition.X > barStartLeft && perMinute > 0)
-            string rowText = "";
+
-            object rowValue = null;
+            minutesAtCursor = Convert.ToInt32((LocalMousePosition.X - barStartLeft) / perMinute);
-            string columnText = "";
+            _mouseOverColumnValue = FromDate.AddMinutes(minutesAtCursor);
         }
-            // Tests to see if the mouse pointer is hovering above the scrollbar
+        else
         {
-            bool scrollBarStatusChanged = false;
+            //_mouseOverColumnValue.TryDispose();
         }
-            // Tests to see if the mouse is hovering over the scroll-area bottom-arrow
+
         // Finds the row at mousepointer
-            if (LocalMousePosition.X > BottomPart.Left & LocalMousePosition.Y < BottomPart.Right & LocalMousePosition.Y < BottomPart.Bottom & LocalMousePosition.Y > BottomPart.Top)
+
         string rowText = "";
-                if (mouseOverBottomPart == false)
+        object rowValue = null;
         string columnText = "";
-                    scrollBarStatusChanged = true;
+
         // Tests to see if the mouse pointer is hovering above the scrollbar
 
-                mouseOverBottomPart = true;
+        bool scrollBarStatusChanged = false;
 
         // Tests to see if the mouse is hovering over the scroll-area bottom-arrow
 
-                if (mouseOverBottomPart == false)
+        if (LocalMousePosition.X > BottomPart.Left & LocalMousePosition.Y < BottomPart.Right & LocalMousePosition.Y < BottomPart.Bottom & LocalMousePosition.Y > BottomPart.Top)
         {
-                    scrollBarStatusChanged = true;
+            if (mouseOverBottomPart == false)
             {
                 scrollBarStatusChanged = true;
-                mouseOverBottomPart = false;
+
 
             mouseOverBottomPart = true;
-            // Tests to see if the mouse is hovering over the scroll-area top-arrow
+
         else
-            if (LocalMousePosition.X > topPart.Left & LocalMousePosition.Y < topPart.Right & LocalMousePosition.Y < topPart.Bottom & LocalMousePosition.Y > topPart.Top)
+
             if (mouseOverBottomPart == false)
-                if (mouseOverTopPart == false)
+
                 scrollBarStatusChanged = true;
-                    scrollBarStatusChanged = true;
+
 
             mouseOverBottomPart = false;
-                mouseOverTopPart = true;
+
 
         // Tests to see if the mouse is hovering over the scroll-area top-arrow
 
-                if (mouseOverTopPart == false)
+        if (LocalMousePosition.X > topPart.Left & LocalMousePosition.Y < topPart.Right & LocalMousePosition.Y < topPart.Bottom & LocalMousePosition.Y > topPart.Top)
         {
-                    scrollBarStatusChanged = true;
+            if (mouseOverTopPart == false)
             {
                 scrollBarStatusChanged = true;
-                mouseOverTopPart = false;
+
 
             mouseOverTopPart = true;
-            // Tests to see if the mouse is hovering over the scroll
+
         else
-            if (LocalMousePosition.X > scroll.Left & LocalMousePosition.Y < scroll.Right & LocalMousePosition.Y < scroll.Bottom & LocalMousePosition.Y > scroll.Top)
+
             if (mouseOverTopPart == false)
-                if (mouseOverScrollBar == false)
+
                 scrollBarStatusChanged = true;
-                    scrollBarStatusChanged = true;
+
 
             mouseOverTopPart = false;
-                mouseOverScrollBar = true;
+
 
         // Tests to see if the mouse is hovering over the scroll
 
         if (LocalMousePosition.X > scroll.Left & LocalMousePosition.Y < scroll.Right & LocalMousePosition.Y < scroll.Bottom & LocalMousePosition.Y > scroll.Top)
-                if (mouseOverScrollBar == false)
+
             if (mouseOverScrollBar == false)
-                    scrollBarStatusChanged = true;
+
                 scrollBarStatusChanged = true;
             }
-                mouseOverScrollBar = false;
+
-                mouseOverScrollBarArea = false;
+            mouseOverScrollBar = true;
             mouseOverScrollBarArea = true;
         }
-            // If the mouse is not above the scroll, test if it's over the scroll area (no need to test if it's not above the scroll)
+        else
         {
-            if (mouseOverScrollBarArea == false)
+            if (mouseOverScrollBar == false)
             {
-                if (LocalMousePosition.X > scrollBarArea.Left & LocalMousePosition.Y < scrollBarArea.Right & LocalMousePosition.Y < scrollBarArea.Bottom & LocalMousePosition.Y > scrollBarArea.Top)
+                scrollBarStatusChanged = true;
             }
-                    mouseOverScrollBarArea = true;
+
             mouseOverScrollBar = false;
             mouseOverScrollBarArea = false;
         }
 
-            // Tests to see if the mouse pointer is hovering above a bar
+        // If the mouse is not above the scroll, test if it's over the scroll area (no need to test if it's not above the scroll)
 
         if (mouseOverScrollBarArea == false)
         {
             if (LocalMousePosition.X > scrollBarArea.Left & LocalMousePosition.Y < scrollBarArea.Right & LocalMousePosition.Y < scrollBarArea.Bottom & LocalMousePosition.Y > scrollBarArea.Top)
             {
                 mouseOverScrollBarArea = true;
-                // If the bar is set to be hidden from mouse move, the current bar will be ignored
+
         }
-                if (bar.HideFromMouseMove == false)
+
 
-                    if (bar.EndValue == null)
+        // Tests to see if the mouse pointer is hovering above a bar
 
-                        bar.EndValue = System.DateTime.Now;
+        int index = 0;
 
 
-                    // Mouse pointer needs to be inside the X and Y positions of the bar
+        foreach (ChartBarDate bar in bars)
         {
-                    if (LocalMousePosition.Y > bar.TopLocation.Left.Y & LocalMousePosition.Y < bar.BottomLocation.Left.Y)
+            // If the bar is set to be hidden from mouse move, the current bar will be ignored
 
             if (bar.HideFromMouseMove == false)
-                        if (LocalMousePosition.X > bar.TopLocation.Left.X & LocalMousePosition.X < bar.TopLocation.Right.X)
+
                 if (bar.EndValue == null)
-                            // If the current bar is the one where the mouse is above, the rowText and rowValue needs to be set correctly
+
                     bar.EndValue = System.DateTime.Now;
-                            rowText = bar.Text;
+
-                            rowValue = bar.Value;
+
                 // Mouse pointer needs to be inside the X and Y positions of the bar
 
-                            if (mouseHoverPart != MouseOverPart.BarLeftSide & mouseHoverPart != MouseOverPart.BarRightSide)
+                if (LocalMousePosition.Y > bar.TopLocation.Left.Y & LocalMousePosition.Y < bar.BottomLocation.Left.Y)
-                            {
+
-                                mouseHoverPart = MouseOverPart.Bar;
+
-                            }
+                    if (LocalMousePosition.X > bar.TopLocation.Left.X & LocalMousePosition.X < bar.TopLocation.Right.X)
                     {
                         // If the current bar is the one where the mouse is above, the rowText and rowValue needs to be set correctly
-                        // If mouse pointer is near the edges of the bar it will open up for editing the bar
+
                         rowText = bar.Text;
-                        if (AllowManualEditBar == true)
+                        rowValue = bar.Value;
                         mouseHoverBarIndex = index;
-                            int areaSize = 5;
+
                         if (mouseHoverPart != MouseOverPart.BarLeftSide & mouseHoverPart != MouseOverPart.BarRightSide)
-                            if (e.Button == System.Windows.Forms.MouseButtons.Left)
+
-                            {
+                            mouseHoverPart = MouseOverPart.Bar;
-                                areaSize = 50;
+
-                            }
+
 
-                            if (LocalMousePosition.X > bar.TopLocation.Left.X - areaSize & LocalMousePosition.X < bar.TopLocation.Left.X + areaSize & mouseHoverPart != MouseOverPart.BarRightSide)
+                    // If mouse pointer is near the edges of the bar it will open up for editing the bar
-                            {
+
-                                this.Cursor = Cursors.VSplit;
+                    if (AllowManualEditBar == true)
-                                mouseHoverPart = MouseOverPart.BarLeftSide;
+
-                                mouseHoverBarIndex = index;
+                        int areaSize = 5;
-                            }
+
-                            else if (LocalMousePosition.X > bar.TopLocation.Right.X - areaSize & LocalMousePosition.X < bar.TopLocation.Right.X + areaSize & mouseHoverPart != MouseOverPart.BarLeftSide)
+                        if (e.Button == System.Windows.Forms.MouseButtons.Left)
-                            {
+
-                                this.Cursor = Cursors.VSplit;
+                            areaSize = 50;
-                                mouseHoverPart = MouseOverPart.BarRightSide;
+
-                                mouseHoverBarIndex = index;
+
-                            }
+                        if (LocalMousePosition.X > bar.TopLocation.Left.X - areaSize & LocalMousePosition.X < bar.TopLocation.Left.X + areaSize & mouseHoverPart != MouseOverPart.BarRightSide)
-                            else
+
-                            {
+                            this.Cursor = Cursors.VSplit;
-                                this.Cursor = Cursors.Default;
+                            mouseHoverPart = MouseOverPart.BarLeftSide;
-                            }
+
                         }
                         else if (LocalMousePosition.X > bar.TopLocation.Right.X - areaSize & LocalMousePosition.X < bar.TopLocation.Right.X + areaSize & mouseHoverPart != MouseOverPart.BarLeftSide)
                         {
                             this.Cursor = Cursors.VSplit;
                             mouseHoverPart = MouseOverPart.BarRightSide;
                             mouseHoverBarIndex = index;
                         }
-            // Sets the mouseover row value and text
+                        else
                         {
-            _mouseOverRowText = rowText;
+                            this.Cursor = Cursors.Default;
-            _mouseOverRowValue = rowValue;
+
                     }
-            if (e.Button == System.Windows.Forms.MouseButtons.Left)
+
             }
-                if (MouseDragged != null)
+
             index += 1;
-                    MouseDragged(sender, e);
+
 
         // Sets the mouseover row value and text
 
         _mouseOverRowText = rowText;
         _mouseOverRowValue = rowValue;
-                // A simple test to see if the mousemovement has caused any changes to how it should be displayed
+
-                // It only redraws if mouse moves from a bar to blank area or from blank area to a bar
+        if (e.Button == System.Windows.Forms.MouseButtons.Left)
-                // This increases performance compared to having a redraw every time a mouse moves
+
             if (MouseDragged != null)
-                if ((_mouseOverRowValue == null & (rowValue != null)) | ((_mouseOverRowValue != null) & rowValue == null) | scrollBarStatusChanged == true)
+
                 MouseDragged(sender, e);
             }
 
         }
         else
         {
             // A simple test to see if the mousemovement has caused any changes to how it should be displayed
-        /// Mouse leave event
+            // It only redraws if mouse moves from a bar to blank area or from blank area to a bar
             // This increases performance compared to having a redraw every time a mouse moves
-        /// <param name="sender"></param>
+
-        /// <param name="e"></param>
+            if ((_mouseOverRowValue == null & (rowValue != null)) | ((_mouseOverRowValue != null) & rowValue == null) | scrollBarStatusChanged == true)
             {
                 PaintChart();
-        private void GanttChart_MouseLeave(System.Object sender, System.EventArgs e)
+
         }
-            _mouseOverRowText = null;
+    }
-            _mouseOverRowValue = null;
+
     /// <summary>
     /// Mouse leave event
-            PaintChart();
+
     /// <param name="sender"></param>
     /// <param name="e"></param>
     /// <remarks></remarks>
-        /// Mouse drag event
+
     private void GanttChart_MouseLeave(System.Object sender, System.EventArgs e)
-        /// <param name="sender"></param>
+
-        /// <param name="e"></param>
+        _mouseOverRowText = null;
         _mouseOverRowValue = null;
         mouseHoverPart = MouseOverPart.Empty;
-        public void GanttChart_MouseDragged(object sender, System.Windows.Forms.MouseEventArgs e)
+
         PaintChart();
-            if (mouseOverScrollBarArea == true)
+    }
 
-                ScrollPositionY = e.Location.Y;
+
     /// Mouse drag event
     /// </summary>
     /// <param name="sender"></param>
     /// <param name="e"></param>
-                if (mouseHoverBarIndex > -1)
+    /// <remarks></remarks>
 
-                    if (mouseHoverPart == MouseOverPart.BarLeftSide)
+    public void GanttChart_MouseDragged(object sender, System.Windows.Forms.MouseEventArgs e)
     {
-                        barIsChanging = mouseHoverBarIndex;
+        if (mouseOverScrollBarArea == true)
-                        bars[mouseHoverBarIndex].StartValue = _mouseOverColumnValue;
+
             ScrollPositionY = e.Location.Y;
         }
-                    else if (mouseHoverPart == MouseOverPart.BarRightSide)
+
         if (AllowManualEditBar == true)
-                        barIsChanging = mouseHoverBarIndex;
+
-                        bars[mouseHoverBarIndex].EndValue = _mouseOverColumnValue;
+            if (mouseHoverBarIndex > -1)
             {
                 if (mouseHoverPart == MouseOverPart.BarLeftSide)
                 {
                     barIsChanging = mouseHoverBarIndex;
                     bars[mouseHoverBarIndex].StartValue = _mouseOverColumnValue;
                     PaintChart();
                 }
-        #endregion
+                else if (mouseHoverPart == MouseOverPart.BarRightSide)
                 {
-        #region "ToolTipText"
+                    barIsChanging = mouseHoverBarIndex;
                     bars[mouseHoverBarIndex].EndValue = _mouseOverColumnValue;
-        private List<string> _toolTipText = new List<string>();
+
                 }
-        private string _toolTipTextTitle = "";
+
         }
-        private Point MyPoint = new Point(0, 0);
+    }
 
-        /// The title to draw
+
     #endregion
 
     #region "ToolTipText"
 
     private List<string> _toolTipText = new List<string>();
-        public string ToolTipTextTitle
+
     private string _toolTipTextTitle = "";
-            get { return _toolTipTextTitle; }
+
-            set { _toolTipTextTitle = value; }
+    private Point MyPoint = new Point(0, 0);
     /// <summary>
     /// The title to draw
     /// </summary>
-        /// Gets or sets the ToolTipText lines
+    /// <value></value>
     /// <returns></returns>
     /// <remarks></remarks>
 
-        /// <remarks>Don not use the add function directly on this, use ToolTipText = value</remarks>
+    public string ToolTipTextTitle
     {
-        public List<string> ToolTipText
+        get { return _toolTipTextTitle; }
         set { _toolTipTextTitle = value; }
-            get
+    }
 
-                if (_toolTipText == null)
+
-                    _toolTipText = new List<string>();
+    /// Gets or sets the ToolTipText lines
-                return _toolTipText;
+
     /// <value></value>
-            set
+    /// <returns></returns>
     /// <remarks>Don not use the add function directly on this, use ToolTipText = value</remarks>
-                _toolTipText = value;
+
     public List<string> ToolTipText
-                Point LocalMousePosition = default(Point);
+
         get
-                LocalMousePosition = this.PointToClient(Cursor.Position);
+
             if (_toolTipText == null)
                 _toolTipText = new List<string>();
-                if (LocalMousePosition == MyPoint)
+            return _toolTipText;
-                    return;
+
         set
-                MyPoint = LocalMousePosition;
+
             _toolTipText = value;
-                ToolTip.SetToolTip(this, ".");
+
             Point LocalMousePosition = default(Point);
 
             LocalMousePosition = this.PointToClient(Cursor.Position);
 
-        /// Draws the ToolTip window
+
             if (LocalMousePosition == MyPoint)
-        /// <param name="sender"></param>
+
-        /// <param name="e"></param>
+
             MyPoint = LocalMousePosition;
 
-        private void ToolTipText_Draw(System.Object sender, System.Windows.Forms.DrawToolTipEventArgs e)
+            ToolTip.SetToolTip(this, ".");
         }
-            if (ToolTipText == null)
+    }
 
-                ToolTipText = new List<string>();
+
     /// Draws the ToolTip window
     /// </summary>
     /// <param name="sender"></param>
-            if (ToolTipText.Count == 0)
+    /// <param name="e"></param>
     /// <remarks></remarks>
 
     private void ToolTipText_Draw(System.Object sender, System.Windows.Forms.DrawToolTipEventArgs e)
-            else if (ToolTipText[0].Length == 0)
+
         if (ToolTipText == null)
         {
             ToolTipText = new List<string>();
             return;
-            int x = 0;
+
-            int y = 0;
+
         if (ToolTipText.Count == 0)
-            e.Graphics.FillRectangle(Brushes.AntiqueWhite, e.Bounds);
+
-            e.DrawBorder();
+            return;
         }
-            int titleHeight = 14;
+        else if (ToolTipText[0].Length == 0)
-            int fontHeight = 12;
+
             return;
-            // Draws the line just below the title
+
 
-            e.Graphics.DrawLine(Pens.Black, 0, titleHeight, e.Bounds.Width, titleHeight);
+        int x = 0;
         int y = 0;
-            int lines = 1;
+
-            string text = ToolTipTextTitle;
+        e.Graphics.FillRectangle(Brushes.AntiqueWhite, e.Bounds);
         e.DrawBorder();
-            // Draws the title
+
         int titleHeight = 14;
-            using (Font font = new Font(e.Font, FontStyle.Bold))
+        int fontHeight = 12;
 
-                x = Convert.ToInt32((e.Bounds.Width - e.Graphics.MeasureString(text, font).Width) / 2);
+        // Draws the line just below the title
-                y = Convert.ToInt32((titleHeight - e.Graphics.MeasureString(text, font).Height) / 2);
+
-                e.Graphics.DrawString(text, font, Brushes.Black, x, y);
+        e.Graphics.DrawLine(Pens.Black, 0, titleHeight, e.Bounds.Width, titleHeight);
 
         int lines = 1;
-            // Draws the lines
+        string text = ToolTipTextTitle;
-            for (int i = 0; i < ToolTipText.Count; i++)
+
         // Draws the title
-                Font font = new Font(e.Font, FontStyle.Regular);
+
         using (Font font = new Font(e.Font, FontStyle.Bold))
-                if (ToolTipText[i].Contains("[b]"))
+
             x = Convert.ToInt32((e.Bounds.Width - e.Graphics.MeasureString(text, font).Width) / 2);
-                    font = new Font(font.FontFamily, font.Size, FontStyle.Bold, font.Unit);
+            y = Convert.ToInt32((titleHeight - e.Graphics.MeasureString(text, font).Height) / 2);
-                    ToolTipText[i] = ToolTipText[i].Replace("[b]", "");
+            e.Graphics.DrawString(text, font, Brushes.Black, x, y);
         }
 
-                using (font)
+        // Draws the lines
         for (int i = 0; i < ToolTipText.Count; i++)
-                    x = 5;
+
-                    y = Convert.ToInt32((titleHeight - fontHeight - e.Graphics.MeasureString(ToolTipText[i], font).Height) / 2 + 10 + (lines * 14));
+            Font font = new Font(e.Font, FontStyle.Regular);
-                    e.Graphics.DrawString(ToolTipText[i], font, Brushes.Black, x, y);
+
             if (ToolTipText[i].Contains("[b]"))
             {
-                lines += 1;
+                font = new Font(font.FontFamily, font.Size, FontStyle.Bold, font.Unit);
                 ToolTipText[i] = ToolTipText[i].Replace("[b]", "");
-            //foreach (string str in ToolTipText)
+
-            //{
+
-            //    Font font = new Font(e.Font, FontStyle.Regular);
+            using (font)
             {
-            //    if (str.Contains("[b]"))
+                x = 5;
-            //    {
+                y = Convert.ToInt32((titleHeight - fontHeight - e.Graphics.MeasureString(ToolTipText[i], font).Height) / 2 + 10 + (lines * 14));
-            //        font = new Font(font.FontFamily, font.Size, FontStyle.Bold, font.Unit);
+                e.Graphics.DrawString(ToolTipText[i], font, Brushes.Black, x, y);
-            //        str = str.Replace("[b]", "");
+
-            //    }
+
             lines += 1;
-            //    using (font)
+
-            //    {
+        //foreach (string str in ToolTipText)
-            //        x = 5;
+        //{
-            //        y = Convert.ToInt32((titleHeight - fontHeight - e.Graphics.MeasureString(str, font).Height) / 2 + 10 + (lines * 14));
+        //    Font font = new Font(e.Font, FontStyle.Regular);
-            //        e.Graphics.DrawString(str, font, Brushes.Black, x, y);
+
-            //    }
+        //    if (str.Contains("[b]"))
         //    {
-            //    lines += 1;
+        //        font = new Font(font.FontFamily, font.Size, FontStyle.Bold, font.Unit);
-            //}
+        //        str = str.Replace("[b]", "");
         //    }
 
         //    using (font)
-        /// Automatically resizes the ToolTip window
+        //    {
         //        x = 5;
-        /// <param name="sender"></param>
+        //        y = Convert.ToInt32((titleHeight - fontHeight - e.Graphics.MeasureString(str, font).Height) / 2 + 10 + (lines * 14));
-        /// <param name="e"></param>
+        //        e.Graphics.DrawString(str, font, Brushes.Black, x, y);
         //    }
 
-        private void ToolTipText_Popup(System.Object sender, System.Windows.Forms.PopupEventArgs e)
+        //    lines += 1;
         //}
-            if (ToolTipText == null)
+    }
 
-                ToolTipText = new List<string>();
+
     /// Automatically resizes the ToolTip window
     /// </summary>
-            if (ToolTipText.Count == 0)
+    /// <param name="sender"></param>
     /// <param name="e"></param>
-                e.ToolTipSize = new Size(0, 0);
+    /// <remarks></remarks>
 
     private void ToolTipText_Popup(System.Object sender, System.Windows.Forms.PopupEventArgs e)
-            else if (ToolTipText[0].Length == 0)
+
         if (ToolTipText == null)
-                e.ToolTipSize = new Size(0, 0);
+
             ToolTipText = new List<string>();
         }
 
-            // resizes the ToolTip window
+        if (ToolTipText.Count == 0)
         {
-            int height = 18 + (ToolTipText.Count * 15);
+            e.ToolTipSize = new Size(0, 0);
-            e.ToolTipSize = new Size(200, height);
+            return;
         }
         else if (ToolTipText[0].Length == 0)
-        #endregion
+
             e.ToolTipSize = new Size(0, 0);
-        #region "ChartBar"
+            return;
         }
-        private class ChartBarDate
+
         // resizes the ToolTip window
 
-            internal class Location
+        int height = 18 + (ToolTipText.Count * 15);
         e.ToolTipSize = new Size(200, height);
     }
-                private Point _right = new Point(0, 0);
+
     #endregion
-                private Point _left = new Point(0, 0);
+
-                public Point Right
+    #region "ChartBar"
 
-                    get { return _right; }
+    private class ChartBarDate
-                    set { _right = value; }
+
 
         internal class Location
-                public Point Left
+
 
-                    get { return _left; }
+            private Point _right = new Point(0, 0);
-                    set { _left = value; }
+
             private Point _left = new Point(0, 0);
             public Point Right
             {
                 get { return _right; }
-            private System.DateTime _startValue;
+                set { _right = value; }
             }
-            private System.DateTime _endValue;
+
-            private Color _color;
+            public Point Left
             {
-            private Color _hoverColor;
+                get { return _left; }
-            private string _text;
+                set { _left = value; }
             }
-            private object _value;
+
         }
-            private int _rowIndex;
+
-            private Location _topLocation = new Location();
+        private System.DateTime _startValue;
 
-            private Location _bottomLocation = new Location();
+        private System.DateTime _endValue;
         private Color _color;
-            private bool _hideFromMouseMove = false;
+
-            public System.DateTime StartValue
+        private Color _hoverColor;
         private string _text;
-                get { return _startValue; }
+
-                set { _startValue = value; }
+        private object _value;
 
         private int _rowIndex;
-            public System.DateTime EndValue
+        private Location _topLocation = new Location();
 
-                get { return _endValue; }
+        private Location _bottomLocation = new Location();
-                set { _endValue = value; }
+
         private bool _hideFromMouseMove = false;
         public System.DateTime StartValue
-            public Color Color
+
             get { return _startValue; }
-                get { return _color; }
+            set { _startValue = value; }
-                set { _color = value; }
+
 
         public System.DateTime EndValue
-            public Color HoverColor
+
             get { return _endValue; }
-                get { return _hoverColor; }
+            set { _endValue = value; }
-                set { _hoverColor = value; }
+
 
         public Color Color
-            public string Text
+
             get { return _color; }
-                get { return _text; }
+            set { _color = value; }
-                set { _text = value; }
+
 
         public Color HoverColor
-            public object Value
+
             get { return _hoverColor; }
-                get { return _value; }
+            set { _hoverColor = value; }
-                set { _value = value; }
+
 
         public string Text
-            public int RowIndex
+
             get { return _text; }
-                get { return _rowIndex; }
+            set { _text = value; }
-                set { _rowIndex = value; }
+
 
         public object Value
-            public bool HideFromMouseMove
+
             get { return _value; }
-                get { return _hideFromMouseMove; }
+            set { _value = value; }
-                set { _hideFromMouseMove = value; }
+
 
         public int RowIndex
-            internal Location TopLocation
+
             get { return _rowIndex; }
-                get { return _topLocation; }
+            set { _rowIndex = value; }
-                set { _topLocation = value; }
+
 
         public bool HideFromMouseMove
-            internal Location BottomLocation
+
             get { return _hideFromMouseMove; }
-                get { return _bottomLocation; }
+            set { _hideFromMouseMove = value; }
-                set { _bottomLocation = value; }
+
 
         internal Location TopLocation
         {
             get { return _topLocation; }
-        #endregion
+            set { _topLocation = value; }
         }
-        #region "Headers"
+
         internal Location BottomLocation
-        private class Header
+
             get { return _bottomLocation; }
             set { _bottomLocation = value; }
-            private string _headerText;
+
-            private int _startLocation;
+
-            private string _headerTextInsteadOfTime = "";
+    }
 
-            private System.DateTime _time;
+    #endregion
-            public string HeaderText
+
     #region "Headers"
-                get { return _headerText; }
+
-                set { _headerText = value; }
+    private class Header
     {
 
-            public int StartLocation
+        private string _headerText;
         private int _startLocation;
-                get { return _startLocation; }
+        private string _headerTextInsteadOfTime = "";
-                set { _startLocation = value; }
+
         private System.DateTime _time;
         public string HeaderText
-            /// <summary>
+
-            /// If this string is larger than 0, this will be used instead of Time
+            get { return _headerText; }
-            /// </summary>
+            set { _headerText = value; }
-            /// <value></value>
+
-            /// <returns></returns>
+
-            /// <remarks></remarks>
+        public int StartLocation
         {
-            public string HeaderTextInsteadOfTime
+            get { return _startLocation; }
             set { _startLocation = value; }
-                get { return _headerTextInsteadOfTime; }
+
-                set { _headerTextInsteadOfTime = value; }
+
         /// <summary>
         /// If this string is larger than 0, this will be used instead of Time
-            /// <summary>
+
-            /// Time to display
+
-            /// </summary>
+
-            /// <value></value>
+
-            /// <returns></returns>
+
-            /// <remarks></remarks>
+        public string HeaderTextInsteadOfTime
         {
-            public System.DateTime Time
+            get { return _headerTextInsteadOfTime; }
             set { _headerTextInsteadOfTime = value; }
-                get { return _time; }
+
-                set { _time = value; }
+
         /// <summary>
         /// Time to display
         /// </summary>
         /// <value></value>
-        #endregion
+
         /// <remarks></remarks>
-        #region "Resize"
+
         public System.DateTime Time
         {
-        /// On resize the Gantt Chart is redrawn
+            get { return _time; }
             set { _time = value; }
-        /// <param name="e"></param>
+
 
     }
-        protected override void OnResize(System.EventArgs e)
+
     #endregion
-            base.OnResize(e);
+
     #region "Resize"
-            scrollPosition = 0;
+
     /// <summary>
-            // Used for when the Gantt Chart is saved as an image
+    /// On resize the Gantt Chart is redrawn
     /// </summary>
-            if (lastLineStop > 0)
+    /// <param name="e"></param>
     /// <remarks></remarks>
-                objBmp = new Bitmap(this.Width - barStartRight, lastLineStop, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
+
-                objGraphics = Graphics.FromImage(objBmp);
+    protected override void OnResize(System.EventArgs e)
     {
         base.OnResize(e);
-            PaintChart();
+
         scrollPosition = 0;
 
-        #endregion
+        // Used for when the Gantt Chart is saved as an image
 
-        #region "Scrollbar"
+        if (lastLineStop > 0)
         {
-        private int barsViewable = -1;
+
-        private int scrollPosition = 0;
+
-        private Rectangle topPart;
+
-        private Rectangle BottomPart;
+
-        private Rectangle scroll;
+        PaintChart();
     }
-        private Rectangle scrollBarArea;
+
-        private bool mouseOverTopPart = false;
+    #endregion
-        private bool mouseOverBottomPart = false;
+
-        private bool mouseOverScrollBar = false;
+    #region "Scrollbar"
 
-        private bool mouseOverScrollBarArea = false;
+    private int barsViewable = -1;
     private int scrollPosition = 0;
-        /// Draws a scrollbar to the component, if there's a need for it
+    private Rectangle topPart;
     private Rectangle BottomPart;
-        /// <param name="grfx"></param>
+    private Rectangle scroll;
 
     private Rectangle scrollBarArea;
-        private void DrawScrollBar(Graphics grfx)
+    private bool mouseOverTopPart = false;
     private bool mouseOverBottomPart = false;
-            barsViewable = (this.Height - barStartTop) / (barHeight + barSpace);
+    private bool mouseOverScrollBar = false;
 
-            if (barCount == 0)
+    private bool mouseOverScrollBarArea = false;
     /// <summary>
     /// Draws a scrollbar to the component, if there's a need for it
     /// </summary>
     /// <param name="grfx"></param>
     /// <remarks></remarks>
-            // If the scroll area is filled there's no need to show the scrollbar
+
     private void DrawScrollBar(Graphics grfx)
-            if (scrollHeight >= maxHeight)
+
         barsViewable = (this.Height - barStartTop) / (barHeight + barSpace);
         int barCount = GetIndexChartBar("QQQWWW");
         if (barCount == 0)
             return;
-            scrollBarArea = new Rectangle(this.Width - 20, 19, 12, maxHeight);
+
-            scroll = new Rectangle(this.Width - 20, 19 + Convert.ToInt32((scrollPosition * scrollSpeed)), 12, Convert.ToInt32(scrollHeight));
+        int maxHeight = this.Height - 30;
         decimal scrollHeight = (maxHeight / barCount) * barsViewable;
-            topPart = new Rectangle(this.Width - 20, 10, 12, 8);
+
-            BottomPart = new Rectangle(this.Width - 20, this.Height - 10, 12, 8);
+        // If the scroll area is filled there's no need to show the scrollbar
 
-            Brush colorTopPart = null;
+        if (scrollHeight >= maxHeight)
-            Brush colorBottomPart = null;
+            return;
-            Brush colorScroll = null;
+
         decimal scrollSpeed = (maxHeight - scrollHeight) / (barCount - barsViewable);
-            if (mouseOverTopPart == true)
+
         scrollBarArea = new Rectangle(this.Width - 20, 19, 12, maxHeight);
-                colorTopPart = Brushes.Black;
+        scroll = new Rectangle(this.Width - 20, 19 + Convert.ToInt32((scrollPosition * scrollSpeed)), 12, Convert.ToInt32(scrollHeight));
 
         topPart = new Rectangle(this.Width - 20, 10, 12, 8);
         BottomPart = new Rectangle(this.Width - 20, this.Height - 10, 12, 8);
-                colorTopPart = Brushes.Gray;
+
         Brush colorTopPart = null;
         Brush colorBottomPart = null;
         Brush colorScroll = null;
 
-                colorBottomPart = Brushes.Black;
+        if (mouseOverTopPart == true)
         {
             colorTopPart = Brushes.Black;
         }
-                colorBottomPart = Brushes.Gray;
+        else
         {
             colorTopPart = Brushes.Gray;
-            if (mouseOverScrollBar == true)
+
 
-                colorScroll = new LinearGradientBrush(scroll, Color.Bisque, Color.Gray, LinearGradientMode.Horizontal);
+        if (mouseOverBottomPart == true)
         {
             colorBottomPart = Brushes.Black;
         }
-                colorScroll = new LinearGradientBrush(scroll, Color.White, Color.Gray, LinearGradientMode.Horizontal);
+        else
         {
             colorBottomPart = Brushes.Gray;
-            // Draws the top and bottom part of the scrollbar
+
 
-            grfx.DrawRectangle(Pens.Black, topPart);
+        if (mouseOverScrollBar == true)
-            grfx.FillRectangle(Brushes.LightGray, topPart);
+
             colorScroll = new LinearGradientBrush(scroll, Color.Bisque, Color.Gray, LinearGradientMode.Horizontal);
-            grfx.DrawRectangle(Pens.Black, BottomPart);
+
-            grfx.FillRectangle(Brushes.LightGray, BottomPart);
+        else
         {
-            // Draws arrows
+            colorScroll = new LinearGradientBrush(scroll, Color.White, Color.Gray, LinearGradientMode.Horizontal);
         }
-            PointF[] points = new PointF[3];
+
-            points[0] = new PointF(topPart.Left, topPart.Bottom - 1);
+        // Draws the top and bottom part of the scrollbar
-            points[1] = new PointF(topPart.Right, topPart.Bottom - 1);
+
-            points[2] = new PointF((topPart.Left + topPart.Right) / 2, topPart.Top + 1);
+        grfx.DrawRectangle(Pens.Black, topPart);
         grfx.FillRectangle(Brushes.LightGray, topPart);
-            grfx.FillPolygon(colorTopPart, points);
+
         grfx.DrawRectangle(Pens.Black, BottomPart);
-            points[0] = new PointF(BottomPart.Left, BottomPart.Top + 1);
+        grfx.FillRectangle(Brushes.LightGray, BottomPart);
-            points[1] = new PointF(BottomPart.Right, BottomPart.Top + 1);
+
-            points[2] = new PointF((BottomPart.Left + BottomPart.Right) / 2, BottomPart.Bottom - 1);
+        // Draws arrows
 
-            grfx.FillPolygon(colorBottomPart, points);
+        PointF[] points = new PointF[3];
         points[0] = new PointF(topPart.Left, topPart.Bottom - 1);
-            // Draws the scroll area
+        points[1] = new PointF(topPart.Right, topPart.Bottom - 1);
         points[2] = new PointF((topPart.Left + topPart.Right) / 2, topPart.Top + 1);
-            grfx.DrawRectangle(Pens.Black, scrollBarArea);
+
-            grfx.FillRectangle(Brushes.DarkGray, scrollBarArea);
+        grfx.FillPolygon(colorTopPart, points);
 
-            // Draws the actual scrollbar
+        points[0] = new PointF(BottomPart.Left, BottomPart.Top + 1);
         points[1] = new PointF(BottomPart.Right, BottomPart.Top + 1);
-            grfx.DrawRectangle(Pens.Black, scroll);
+        points[2] = new PointF((BottomPart.Left + BottomPart.Right) / 2, BottomPart.Bottom - 1);
-            grfx.FillRectangle(colorScroll, scroll);
+
         grfx.FillPolygon(colorBottomPart, points);
 
         // Draws the scroll area
-        /// The Y-position of the center of the scroll
+
         grfx.DrawRectangle(Pens.Black, scrollBarArea);
         grfx.FillRectangle(Brushes.DarkGray, scrollBarArea);
 
         // Draws the actual scrollbar
 
-        private int ScrollPositionY
+        grfx.DrawRectangle(Pens.Black, scroll);
         grfx.FillRectangle(colorScroll, scroll);
-            get
+    }
 
-                if (scroll == null)
+
-                    return -1;
+    /// The Y-position of the center of the scroll
-                return ((scroll.Height / 2) + scroll.Location.Y) + 19;
+
     /// <value></value>
-            set
+    /// <returns></returns>
     /// <remarks></remarks>
-                int barCount = GetIndexChartBar("QQQWWW");
+
-                int maxHeight = this.Height - 30;
+    private int ScrollPositionY
-                decimal scrollHeight = (maxHeight / barCount) * barsViewable;
+
-                decimal scrollSpeed = (maxHeight - scrollHeight) / (barCount - barsViewable);
+        get
-                int index = 0;
+
-                dynamic distanceFromLastPosition = 9999;
+            if (scroll == null)
                 return -1;
-                // Tests to see what scrollposition is the closest to the set position
+            return ((scroll.Height / 2) + scroll.Location.Y) + 19;
         }
-                while (index < barCount)
+        set
         {
-                    int newPositionTemp = Convert.ToInt32((index * scrollSpeed) + (scrollHeight / 2) + (30 / 2));
+
-                    dynamic distanceFromCurrentPosition = newPositionTemp - value;
+
             decimal scrollHeight = (maxHeight / barCount) * barsViewable;
-                    if (distanceFromLastPosition < 0)
+
             int index = 0;
-                        if (distanceFromCurrentPosition < distanceFromLastPosition)
+            dynamic distanceFromLastPosition = 9999;
 
-                            scrollPosition = index - 1;
+            // Tests to see what scrollposition is the closest to the set position
-                            PaintChart();
+
-                            return;
+            while (index < barCount)
             {
                 int newPositionTemp = Convert.ToInt32((index * scrollSpeed) + (scrollHeight / 2) + (30 / 2));
-                    else
+                dynamic distanceFromCurrentPosition = newPositionTemp - value;
 
-                        if (distanceFromCurrentPosition > distanceFromLastPosition)
+                if (distanceFromLastPosition < 0)
                 {
-                            scrollPosition = index - 1;
+                    if (distanceFromCurrentPosition < distanceFromLastPosition)
                     {
-                            // A precaution to make sure the scroll bar doesn't go too far down
+                        scrollPosition = index - 1;
                         PaintChart();
-                            if (scrollPosition + barsViewable > GetIndexChartBar("QQQWWW"))
+                        return;
-                            {
+
-                                scrollPosition = GetIndexChartBar("QQQWWW") - barsViewable;
+
-                            }
+
                 {
-                            PaintChart();
+                    if (distanceFromCurrentPosition > distanceFromLastPosition)
-                            return;
+
                         scrollPosition = index - 1;
 
                         // A precaution to make sure the scroll bar doesn't go too far down
-                    distanceFromLastPosition = distanceFromCurrentPosition;
+
                         if (scrollPosition + barsViewable > GetIndexChartBar("QQQWWW"))
-                    index += 1;
+
                             scrollPosition = GetIndexChartBar("QQQWWW") - barsViewable;
                         }
 
                         PaintChart();
                         return;
-        /// Scrolls one row up
+
                 }
 
                 distanceFromLastPosition = distanceFromCurrentPosition;
-        public void ScrollOneup()
+
                 index += 1;
-            if (scrollPosition == 0)
+
         }
     }
-            scrollPosition -= 1;
+
     /// <summary>
-            PaintChart();
+    /// Scrolls one row up
     /// </summary>
     /// <remarks></remarks>
 
-        /// Scrolls one row down
+    public void ScrollOneup()
     {
         if (scrollPosition == 0)
             return;
-        public void ScrollOneDown()
+
         scrollPosition -= 1;
-            if (scrollPosition + barsViewable >= GetIndexChartBar("QQQWWW"))
+
         PaintChart();
     }
-            scrollPosition += 1;
+
     /// <summary>
-            PaintChart();
+    /// Scrolls one row down
     /// </summary>
     /// <remarks></remarks>
 
-        /// If the user clicks on the scrollbar, scrolling functions will be called
+    public void ScrollOneDown()
     {
-        /// <param name="sender"></param>
+        if (scrollPosition + barsViewable >= GetIndexChartBar("QQQWWW"))
-        /// <param name="e"></param>
+            return;
 
         scrollPosition += 1;
-        private void GanttChart_Click(System.Object sender, System.Windows.Forms.MouseEventArgs e)
+
         PaintChart();
-            if (e.Button == System.Windows.Forms.MouseButtons.Left)
+    }
 
-                if (mouseOverBottomPart == true)
+
     /// If the user clicks on the scrollbar, scrolling functions will be called
-                    ScrollOneDown();
+
     /// <param name="sender"></param>
-                else if (mouseOverTopPart == true)
+    /// <param name="e"></param>
     /// <remarks></remarks>
-                    ScrollOneup();
+
     private void GanttChart_Click(System.Object sender, System.Windows.Forms.MouseEventArgs e)
     {
         if (e.Button == System.Windows.Forms.MouseButtons.Left)
         {
             if (mouseOverBottomPart == true)
-        /// When mousewheel is used, the scrollbar will scroll
+
                 ScrollOneDown();
-        /// <param name="sender"></param>
+
-        /// <param name="e"></param>
+            else if (mouseOverTopPart == true)
             {
                 ScrollOneup();
-        private void GanttChart_MouseWheel(object sender, System.Windows.Forms.MouseEventArgs e)
+
         }
-            if (e.Delta > 0)
+    }
 
     /// <summary>
     /// When mousewheel is used, the scrollbar will scroll
     /// </summary>
     /// <param name="sender"></param>
     /// <param name="e"></param>
     /// <remarks></remarks>
 
     private void GanttChart_MouseWheel(object sender, System.Windows.Forms.MouseEventArgs e)
-        #endregion
+
         if (e.Delta > 0)
-        #region "Save"
+
             ScrollOneup();
         }
-        /// Saves the GanttChart to specified image file
+        else
         {
-        /// <param name="filePath"></param>
+            ScrollOneDown();
         }
     }
-        public void SaveImage(string filePath)
+
     #endregion
-            objGraphics.SmoothingMode = SmoothingMode.HighSpeed;
+
-            objGraphics.Clear(this.BackColor);
+    #region "Save"
 
-            if (headerFromDate == null | headerToDate == null)
+
     /// Saves the GanttChart to specified image file
     /// </summary>
-            DrawHeader(objGraphics, null);
+    /// <param name="filePath"></param>
-            DrawNetHorizontal(objGraphics);
+    /// <remarks></remarks>
-            DrawNetVertical(objGraphics);
+
-            DrawBars(objGraphics, true);
+    public void SaveImage(string filePath)
     {
-            objBmp.Save(filePath);
+        objGraphics.SmoothingMode = SmoothingMode.HighSpeed;
         objGraphics.Clear(this.BackColor);
 
-        #endregion
+        if (headerFromDate == null | headerToDate == null)
             return;
-        private enum MouseOverPart
+
         DrawHeader(objGraphics, null);
         DrawNetHorizontal(objGraphics);
-            Empty,
+        DrawNetVertical(objGraphics);
-            Bar,
+        DrawBars(objGraphics, true);
-            BarLeftSide,
+
-            BarRightSide
+        objBmp.Save(filePath);
     }
 
     #endregion
-    }
+
     private enum MouseOverPart
     {
 
         Empty,
         Bar,
         BarLeftSide,
         BarRightSide
 
     }
 
 }