2313 lines
86 KiB
C#
2313 lines
86 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Data;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Drawing.Printing;
|
|
|
|
namespace Braincase.GanttChart
|
|
{
|
|
static class GDIExtention
|
|
{
|
|
public static void DrawRectangle(this Graphics graphics, Pen pen, RectangleF rectangle)
|
|
{
|
|
graphics.DrawRectangle(pen, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gantt Chart control
|
|
/// </summary>
|
|
public partial class Chart : UserControl
|
|
{
|
|
/// <summary>
|
|
/// Construct a gantt chart
|
|
/// </summary>
|
|
public Chart()
|
|
{
|
|
// Designer values
|
|
InitializeComponent();
|
|
|
|
// Factory values
|
|
//HeaderOneHeight = 32;
|
|
//HeaderTwoHeight = 20;
|
|
|
|
HeaderOneHeight = 32;
|
|
HeaderTwoHeight = 20;
|
|
BarSpacing = 16;
|
|
BarHeight = 10;
|
|
BarWidth = 40;
|
|
ZoomScaleIndex = 4;
|
|
this.DoubleBuffered = true;
|
|
var viewport = new ControlViewport(this);
|
|
viewport.WheelDelta = BarSpacing;
|
|
_mViewport = viewport;
|
|
TimeScaleDisplay = GanttChart.TimeScaleDisplay.DayOfMonth;
|
|
AllowTaskDragDrop = true;
|
|
ShowRelations = true;
|
|
ShowSlack = false;
|
|
AccumulateRelationsOnGroup = false;
|
|
ShowTaskLabels = true;
|
|
this.Dock = DockStyle.Fill;
|
|
this.Margin = new Padding(0, 0, 0, 0);
|
|
this.Padding = new Padding(0, 0, 0, 0);
|
|
// Formatting
|
|
TaskFormat = new GanttChart.TaskFormat()
|
|
{
|
|
Color = Brushes.Black,
|
|
Border = Pens.Maroon,
|
|
BackFill = Brushes.MediumSlateBlue,
|
|
ForeFill = Brushes.YellowGreen,
|
|
SlackFill = new System.Drawing.Drawing2D.HatchBrush(
|
|
System.Drawing.Drawing2D.HatchStyle.LightDownwardDiagonal, Color.Blue, Color.Transparent)
|
|
};
|
|
CriticalTaskFormat = new GanttChart.TaskFormat()
|
|
{
|
|
Color = Brushes.Black,
|
|
Border = Pens.Maroon,
|
|
BackFill = Brushes.Crimson,
|
|
ForeFill = Brushes.YellowGreen,
|
|
SlackFill = new System.Drawing.Drawing2D.HatchBrush(
|
|
System.Drawing.Drawing2D.HatchStyle.LightDownwardDiagonal, Color.Red, Color.Transparent)
|
|
};
|
|
HeaderFormat = new GanttChart.HeaderFormat()
|
|
{
|
|
Color = Brushes.Black,
|
|
Border = new Pen(SystemColors.ActiveBorder),
|
|
GradientLight = SystemColors.ButtonHighlight,
|
|
GradientDark = SystemColors.ButtonFace
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delegate method for creating a new Task. Creates Task by default.
|
|
/// </summary>
|
|
public Func<Task> CreateTaskDelegate = delegate() { return new Task(); };
|
|
|
|
/// <summary>
|
|
/// Get the selected tasks
|
|
/// </summary>
|
|
public IEnumerable<Task> SelectedTasks
|
|
{
|
|
get { return _mSelectedTasks.ToArray(); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the latest selected task
|
|
/// </summary>
|
|
public Task SelectedTask
|
|
{
|
|
get { return _mSelectedTasks.LastOrDefault(); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get or set header1 pixel height
|
|
/// </summary>
|
|
[DefaultValue(32)]
|
|
public int HeaderOneHeight { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set the DateTime string format. Default value is D/M/YYYY
|
|
/// </summary>
|
|
[DefaultValue("D/M/YYYY")]
|
|
public string FullDateStringFormat { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set header2 pixel height
|
|
/// </summary>
|
|
[DefaultValue(20)]
|
|
public int HeaderTwoHeight { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set pixel distance from top of each Task to the next
|
|
/// </summary>
|
|
[DefaultValue(26)]
|
|
public int BarSpacing { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set pixel height of each Task
|
|
/// </summary>
|
|
[DefaultValue(20)]
|
|
public int BarHeight { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set pixel width of each unit of period
|
|
/// </summary>
|
|
[DefaultValue(20)]
|
|
public float BarWidth { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set format for Tasks
|
|
/// </summary>
|
|
public TaskFormat TaskFormat { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set format for critical Tasks
|
|
/// </summary>
|
|
public TaskFormat CriticalTaskFormat { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set format for headers
|
|
/// </summary>
|
|
public HeaderFormat HeaderFormat { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set format for relations
|
|
/// </summary>
|
|
public RelationFormat RelationFormat { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set whether dragging of Tasks is allowed. Set to false when not dragging to skip drag(drop) tracking.
|
|
/// </summary>
|
|
[DefaultValue(true)]
|
|
public bool AllowTaskDragDrop { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set whether to show relations
|
|
/// </summary>
|
|
[DefaultValue(true)]
|
|
public bool ShowRelations { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set format for headers wangdequan
|
|
/// </summary>
|
|
[DefaultValue(1f)]
|
|
public float HeaderScale { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set format for headers wangdequan Max = 10;Min=0
|
|
/// </summary>
|
|
[DefaultValue(4)]
|
|
public int ZoomScaleIndex { get; set; }
|
|
|
|
public float[] ZoomScaleList = {0.01f, 0.2f, 0.4f, 0.5f, 1f, 2f, 4f, 5f, 10f, 20f, 60f};
|
|
|
|
/// <summary>
|
|
/// Get or set whether to show task labels
|
|
/// </summary>
|
|
[DefaultValue(true)]
|
|
public bool ShowTaskLabels { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set whether to accumulate relations on group tasks and show relations even when group is collapsed. (Not working well; still improving on it)
|
|
/// </summary>
|
|
[DefaultValue(false)]
|
|
public bool AccumulateRelationsOnGroup { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set whether to show slack
|
|
/// </summary>
|
|
[DefaultValue(false)]
|
|
public bool ShowSlack { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set the time scale display format
|
|
/// </summary>
|
|
[DefaultValue(TimeScaleDisplay.DayOfMonth)]
|
|
public TimeScaleDisplay TimeScaleDisplay { get; set; }
|
|
|
|
/// <summary>
|
|
/// Occurs when the mouse is moving over a Task
|
|
/// </summary>
|
|
public event EventHandler<TaskMouseEventArgs> TaskMouseOver = null;
|
|
|
|
/// <summary>
|
|
/// Occurs when the mouse leaves a Task
|
|
/// </summary>
|
|
public event EventHandler<TaskMouseEventArgs> TaskMouseOut = null;
|
|
|
|
/// <summary>
|
|
/// Occurs when a Task is clicked
|
|
/// </summary>
|
|
public event EventHandler<TaskMouseEventArgs> TaskMouseClick = null;
|
|
|
|
/// <summary>
|
|
/// TaskMouseDown
|
|
/// </summary>
|
|
public event EventHandler<TaskMouseEventArgs> TaskMouseDown = null;
|
|
|
|
/// <summary>
|
|
/// Occurs when a Task is double clicked by the mouse
|
|
/// </summary>
|
|
public event EventHandler<TaskMouseEventArgs> TaskMouseDoubleClick = null;
|
|
|
|
/// <summary>
|
|
/// Occurs when a Task is being dragged by the mouse
|
|
/// </summary>
|
|
public event EventHandler<TaskDragDropEventArgs> TaskMouseDrag = null;
|
|
|
|
/// <summary>
|
|
/// Occurs when a dragged Task is being dropped by releasing any previously pressed mouse button.
|
|
/// </summary>
|
|
public event EventHandler<TaskDragDropEventArgs> TaskMouseDrop = null;
|
|
|
|
/// <summary>
|
|
/// Occurs when a task is selected.
|
|
/// </summary>
|
|
public event EventHandler<TaskMouseEventArgs> TaskSelected = null;
|
|
|
|
/// <summary>
|
|
/// Occurs before one or more tasks are being deselected. All Task in Chart.SelectedTasks will be deselected.
|
|
/// </summary>
|
|
public event EventHandler<TaskMouseEventArgs> TaskDeselecting = null;
|
|
|
|
/// <summary>
|
|
/// Occurs before a Task gets painted
|
|
/// </summary>
|
|
public event EventHandler<TaskPaintEventArgs> PaintTask = null;
|
|
|
|
/// <summary>
|
|
/// Occurs before overlays get painted
|
|
/// </summary>
|
|
public event EventHandler<ChartPaintEventArgs> PaintOverlay = null;
|
|
|
|
/// <summary>
|
|
/// Occurs before the header gets painted
|
|
/// </summary>
|
|
public event EventHandler<HeaderPaintEventArgs> PaintHeader = null;
|
|
|
|
/// <summary>
|
|
/// Get the line number of the specified task
|
|
/// </summary>
|
|
/// <param name="task"></param>
|
|
/// <param name="row"></param>
|
|
/// <returns></returns>
|
|
public bool TryGetRow(Task task, out int row)
|
|
{
|
|
row = 0;
|
|
if (_mChartTaskHitRects.ContainsKey(task))
|
|
{
|
|
// collection contains parts
|
|
row = _ChartCoordToChartRow(_mChartTaskHitRects[task].Top);
|
|
return true;
|
|
}
|
|
else if (_mChartTaskRects.ContainsKey(task))
|
|
{
|
|
// collectino contains splits
|
|
row = _ChartCoordToChartRow(_mChartTaskRects[task].Top);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the task at the specified line number
|
|
/// </summary>
|
|
/// <param name="row"></param>
|
|
/// <param name="task"></param>
|
|
/// <returns></returns>
|
|
public bool TryGetTask(int row, out Task task)
|
|
{
|
|
task = null;
|
|
if (row > 0 && row < _mProject.Tasks.Count())
|
|
{
|
|
task = _mChartTaskRects.ElementAtOrDefault(row - 1).Key;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initialize this Chart with a Project
|
|
/// </summary>
|
|
/// <param name="project"></param>
|
|
public void Init(ProjectManager<Task, object> project)
|
|
{
|
|
_mProject = project;
|
|
HeaderScale = 1.0f;
|
|
_GenerateModels();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print the Chart to the specified PrintDocument.
|
|
/// </summary>
|
|
public void Print(PrintDocument document, float scale = 1.0f)
|
|
{
|
|
// save a copy of the current viewport and swap it with PrintViewport
|
|
var viewport = _mViewport;
|
|
|
|
float x = 0; // viewport world x, y coords
|
|
float y = 0;
|
|
int pageCount = 0;
|
|
|
|
document.PrintPage += (s, e) =>
|
|
{
|
|
e.HasMorePages = false;
|
|
pageCount++;
|
|
|
|
// create a PrintViewport to navigate the world
|
|
var printViewport = new PrintViewport(e.Graphics,
|
|
viewport.WorldWidth, viewport.WorldHeight,
|
|
e.MarginBounds.Width, e.MarginBounds.Height,
|
|
e.PageSettings.Margins.Left, e.PageSettings.Margins.Right);
|
|
printViewport.Scale = scale;
|
|
_mViewport = printViewport;
|
|
|
|
// move the viewport
|
|
printViewport.X = x;
|
|
printViewport.Y = y;
|
|
|
|
// set clip and draw
|
|
e.Graphics.SetClip(e.MarginBounds);
|
|
_Draw(e.Graphics, e.PageBounds);
|
|
|
|
// check if reached end of printing
|
|
if (printViewport.Rectangle.Right < printViewport.WorldWidth)
|
|
{
|
|
// continue horizontally
|
|
x += printViewport.Rectangle.Width;
|
|
e.HasMorePages = true;
|
|
}
|
|
else
|
|
{
|
|
// reached end of worldwidth so we go down vertically once
|
|
x = 0;
|
|
if (printViewport.Rectangle.Bottom < printViewport.WorldHeight)
|
|
{
|
|
y += printViewport.Rectangle.Height;
|
|
e.HasMorePages = true;
|
|
}
|
|
}
|
|
};
|
|
document.Print();
|
|
|
|
// restore the viewport
|
|
_mViewport = viewport;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print the Chart to the specified Image
|
|
/// </summary>
|
|
/// <param name="scale">Scale to print the image at.</param>
|
|
public Bitmap Print(float scale = 1.0f)
|
|
{
|
|
var viewport = _mViewport;
|
|
_mViewport = new ImageViewport(scale, viewport.WorldWidth, viewport.WorldHeight);
|
|
|
|
Bitmap image = new Bitmap((int) Math.Ceiling(viewport.WorldWidth * scale),
|
|
(int) Math.Ceiling(viewport.WorldHeight * scale));
|
|
var graphics = Graphics.FromImage(image);
|
|
|
|
_Draw(graphics, Rectangle.Ceiling(viewport.Rectangle));
|
|
|
|
_mViewport = viewport;
|
|
|
|
return image;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get information about the chart area at the mouse coordinate of the chart
|
|
/// </summary>
|
|
/// <param name="mouse"></param>
|
|
/// <returns></returns>
|
|
public ChartInfo GetChartInfo(Point mouse)
|
|
{
|
|
var row = _ChartCoordToChartRow(mouse.Y);
|
|
var col = _GetDeviceColumnUnderMouse(mouse);
|
|
var task = _GetTaskUnderMouse(mouse);
|
|
return new ChartInfo(row, _mHeaderInfo.Dates[col], task);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set tool tip for the specified task
|
|
/// </summary>
|
|
/// <param name="task"></param>
|
|
/// <param name="text"></param>
|
|
public void SetToolTip(Task task, string text)
|
|
{
|
|
if (task != null && text != string.Empty)
|
|
_mTaskToolTip[task] = text;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get tool tip currently set for the specified task
|
|
/// </summary>
|
|
/// <param name="task"></param>
|
|
/// <param name="text"></param>
|
|
/// <returns></returns>
|
|
public string GetToolTip(Task task)
|
|
{
|
|
if (task != null)
|
|
return _mTaskToolTip[task];
|
|
else
|
|
return string.Empty;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clear tool tip for the specified task
|
|
/// </summary>
|
|
/// <param name="task"></param>
|
|
public void ClearToolTip(Task task)
|
|
{
|
|
if (task != null)
|
|
_mTaskToolTip.Remove(task);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clear all tool tips
|
|
/// </summary>
|
|
public void ClearToolTips()
|
|
{
|
|
_mTaskToolTip.Clear();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scroll to the specified DateTime
|
|
/// </summary>
|
|
/// <param name="datetime"></param>
|
|
public void ScrollTo(DateTime datetime)
|
|
{
|
|
TimeSpan span = datetime - _mProject.Start;
|
|
_mViewport.X = span.Days * this.BarWidth;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scroll to the specified task
|
|
/// </summary>
|
|
/// <param name="task"></param>
|
|
public void ScrollTo(Task task)
|
|
{
|
|
if (_mChartTaskRects.ContainsKey(task))
|
|
{
|
|
var rect = _mChartTaskRects[task];
|
|
_mViewport.X = rect.Left - this.BarWidth;
|
|
_mViewport.Y = rect.Top - this.HeaderOneHeight - this.HeaderTwoHeight;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Begin billboard mode. Graphics must orginate from Chart and be same as that used in EndBillboardMode.
|
|
/// </summary>
|
|
/// <param name="graphics"></param>
|
|
public void BeginBillboardMode(Graphics graphics)
|
|
{
|
|
graphics.Transform = ControlViewport.Identity;
|
|
}
|
|
|
|
/// <summary>
|
|
/// End billboard mode. Graphics must orginate from Chart and be same as that used in BeginBillboardMode.
|
|
/// </summary>
|
|
/// <param name="graphics"></param>
|
|
public void EndBillboardMode(Graphics graphics)
|
|
{
|
|
graphics.Transform = _mViewport.Projection;
|
|
}
|
|
|
|
#region UserControl Events
|
|
|
|
/// <summary>
|
|
/// Raises the System.Windows.Forms.Control.Paint event
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected override void OnPaint(PaintEventArgs e)
|
|
{
|
|
base.OnPaint(e);
|
|
|
|
if (!this.DesignMode)
|
|
this._Draw(e.Graphics, e.ClipRectangle);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises the System.Windows.Forms.Control.MouseMove event
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected override void OnMouseMove(MouseEventArgs e)
|
|
{
|
|
// Hot tracking
|
|
var task = _GetTaskUnderMouse(e.Location);
|
|
if (_mMouseEntered != null && task == null)
|
|
{
|
|
OnTaskMouseOut(new TaskMouseEventArgs(_mMouseEntered, RectangleF.Empty, e.Button, e.Clicks, e.X, e.Y,
|
|
e.Delta));
|
|
_mMouseEntered = null;
|
|
}
|
|
else if (_mMouseEntered == null && task != null)
|
|
{
|
|
_mMouseEntered = task;
|
|
OnTaskMouseOver(new TaskMouseEventArgs(_mMouseEntered, _mChartTaskHitRects[task], e.Button, e.Clicks,
|
|
e.X, e.Y, e.Delta));
|
|
}
|
|
|
|
// Dragging
|
|
if (AllowTaskDragDrop && _mDragSource != null)
|
|
{
|
|
try
|
|
{
|
|
Task target = task;
|
|
if (target == _mDragSource) target = null;
|
|
RectangleF targetRect = target == null ? RectangleF.Empty : _mChartTaskHitRects[target];
|
|
int row = _DeviceCoordToChartRow(e.Location.Y);
|
|
OnTaskMouseDrag(new TaskDragDropEventArgs(_mDragStartLocation, _mDragLastLocation, _mDragSource,
|
|
_mChartTaskHitRects[_mDragSource], target, targetRect, row, e.Button, e.Clicks, e.X, e.Y, e.Delta));
|
|
_mDragLastLocation = e.Location;
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//TaskMouseDrop(this, e);
|
|
//绘制播放滑块
|
|
OnMouseMove_PlaySlider(e);
|
|
base.OnMouseMove(e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises the System.Windows.Forms.Control.MouseClick event
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected override void OnMouseClick(MouseEventArgs e)
|
|
{
|
|
var task = _GetTaskUnderMouse(e.Location);
|
|
if (task != null)
|
|
{
|
|
OnTaskMouseClick(new TaskMouseEventArgs(task, _mChartTaskHitRects[task], e.Button, e.Clicks, e.X, e.Y,
|
|
e.Delta));
|
|
}
|
|
else
|
|
{
|
|
OnTaskDeselecting(new TaskMouseEventArgs(task, RectangleF.Empty, e.Button, e.Clicks, e.X, e.Y,
|
|
e.Delta));
|
|
this.Invalidate();
|
|
}
|
|
|
|
base.OnMouseClick(e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises the System.Windows.Forms.Control.MouseDown event
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected override void OnMouseDown(MouseEventArgs e)
|
|
{
|
|
// Begin Drag
|
|
if (AllowTaskDragDrop)
|
|
{
|
|
_mDragSource = _GetTaskUnderMouse(e.Location);
|
|
if (_mDragSource != null)
|
|
{
|
|
_mDragStartLocation = e.Location;
|
|
_mDragLastLocation = e.Location;
|
|
}
|
|
}
|
|
|
|
//拖动播放条
|
|
OnMouseDown_PlaySlider(e);
|
|
//2021.8.19.LLX
|
|
try
|
|
{
|
|
var task = _GetTaskUnderMouse(e.Location);
|
|
if (task != null)
|
|
{
|
|
if (TaskMouseDown != null)
|
|
TaskMouseDown.Invoke(this,
|
|
new TaskMouseEventArgs(task, _mChartTaskHitRects[task], e.Button, e.Clicks, e.X, e.Y,
|
|
e.Delta)
|
|
);
|
|
}
|
|
}
|
|
catch (Exception err)
|
|
{
|
|
}
|
|
|
|
|
|
base.OnMouseDown(e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises the System.Windows.Forms.Control.MouseUp event
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected override void OnMouseUp(MouseEventArgs e)
|
|
{
|
|
// Drop task
|
|
if (AllowTaskDragDrop && _mDragSource != null)
|
|
{
|
|
try
|
|
{
|
|
var target = _GetTaskUnderMouse(e.Location);
|
|
if (target == _mDragSource) target = null;
|
|
var targetRect = target == null ? RectangleF.Empty : _mChartTaskHitRects[target];
|
|
int row = _DeviceCoordToChartRow(e.Location.Y);
|
|
OnTaskMouseDrop(new TaskDragDropEventArgs(_mDragStartLocation, _mDragLastLocation, _mDragSource,
|
|
_mChartTaskHitRects[_mDragSource], target, targetRect, row, e.Button, e.Clicks, e.X, e.Y, e.Delta));
|
|
_mDragSource = null;
|
|
_mDragLastLocation = Point.Empty;
|
|
_mDragStartLocation = Point.Empty;
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//if (!_mHeaderInfo.H1Rect.Contains(chartcoord)
|
|
// && !_mHeaderInfo.H2Rect.Contains(chartcoord))
|
|
//{
|
|
// foreach (var task in _mChartTaskHitRects.Keys)
|
|
// {
|
|
// if (_mChartTaskHitRects[task].Contains(chartcoord))
|
|
// return task;
|
|
// }
|
|
//}
|
|
//PlayMaskRectDragDrop
|
|
|
|
base.OnMouseUp(e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises the System.Windows.Forms.Control.MouseDoubleClick event
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected override void OnMouseDoubleClick(MouseEventArgs e)
|
|
{
|
|
var task = _GetTaskUnderMouse(e.Location);
|
|
if (task != null)
|
|
{
|
|
OnTaskMouseDoubleClick(new TaskMouseEventArgs(task, _mChartTaskHitRects[task], e.Button, e.Clicks, e.X,
|
|
e.Y, e.Delta));
|
|
}
|
|
|
|
base.OnMouseDoubleClick(e);
|
|
}
|
|
|
|
#endregion UserControl Events
|
|
|
|
#region Chart Events
|
|
|
|
/// <summary>
|
|
/// Raises the TaskMouseOver event
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual void OnTaskMouseOver(TaskMouseEventArgs e)
|
|
{
|
|
if (TaskMouseOver != null)
|
|
TaskMouseOver(this, e);
|
|
|
|
this.Cursor = Cursors.Hand;
|
|
|
|
var task = e.Task;
|
|
if (_mProject.IsPart(e.Task)) task = _mProject.SplitTaskOf(task);
|
|
if (_mTaskToolTip.ContainsKey(task))
|
|
{
|
|
_mOverlay.ShowToolTip(_mViewport.DeviceToWorldCoord(e.Location), _mTaskToolTip[task]);
|
|
this.Invalidate();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises the TaskMouseOver event
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual void OnTaskMouseOut(TaskMouseEventArgs e)
|
|
{
|
|
if (TaskMouseOut != null)
|
|
TaskMouseOut(this, e);
|
|
|
|
this.Cursor = Cursors.Default;
|
|
|
|
_mOverlay.HideToolTip();
|
|
this.Invalidate();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises the TaskMouseDrag( event
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual void OnTaskMouseDrag(TaskDragDropEventArgs e)
|
|
{
|
|
//// Default drag behaviors **********************************
|
|
//if (e.Button == System.Windows.Forms.MouseButtons.Middle)
|
|
//{
|
|
// var complete = e.Source.Complete + (float)(e.X - e.PreviousLocation.X) / (e.Source.Duration * this.BarWidth);
|
|
// _mProject.SetComplete(e.Source, complete);
|
|
//}
|
|
//else if (e.Button == System.Windows.Forms.MouseButtons.Right)
|
|
//{
|
|
// if (e.Target == null)
|
|
// {
|
|
// var delta = (e.PreviousLocation.X - e.StartLocation.X);
|
|
// _mOverlay.DraggedRect = e.SourceRect;
|
|
// _mOverlay.DraggedRect.Width += delta;
|
|
// }
|
|
// else // drop targetting (join)
|
|
// {
|
|
// _mOverlay.DraggedRect = e.TargetRect;
|
|
// _mOverlay.Row = int.MinValue;
|
|
// }
|
|
//}
|
|
//else
|
|
if (e.Button == System.Windows.Forms.MouseButtons.Left)
|
|
{
|
|
_mOverlay.Clear();
|
|
|
|
if (e.Target == null)
|
|
{
|
|
// 屏蔽
|
|
//if (Control.ModifierKeys.HasFlag(Keys.Shift))
|
|
//{
|
|
// // insertion line
|
|
// _mOverlay.Row = e.Row;
|
|
//}
|
|
//else
|
|
{
|
|
// displacing horizontally
|
|
_mOverlay.DraggedRect = e.SourceRect;
|
|
_mOverlay.DraggedRect.Offset((e.X - e.StartLocation.X) / this.BarWidth * this.BarWidth, 0);
|
|
}
|
|
}
|
|
// 屏蔽
|
|
//else // drop targetting (subtask / predecessor)
|
|
//{
|
|
// _mOverlay.DraggedRect = e.TargetRect;
|
|
// _mOverlay.Row = int.MinValue;
|
|
//}
|
|
}
|
|
|
|
// fire listeners
|
|
if (TaskMouseDrag != null)
|
|
TaskMouseDrag(this, e);
|
|
this.Invalidate();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises the TaskMouseDrop event
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual void OnTaskMouseDrop(TaskDragDropEventArgs e)
|
|
{
|
|
// Fire event
|
|
//if (TaskMouseDrop != null)
|
|
// TaskMouseDrop(this, e);
|
|
|
|
var delta = (e.PreviousLocation.X - e.StartLocation.X) / this.BarWidth;
|
|
delta = (float) Math.Round(delta, 1);
|
|
if (e.Button == System.Windows.Forms.MouseButtons.Left)
|
|
{
|
|
if (e.Target == null)
|
|
{
|
|
// 屏蔽修改顺序
|
|
//if (Control.ModifierKeys.HasFlag(Keys.Shift))
|
|
//{
|
|
// // insert
|
|
// int from;
|
|
// Task source = e.Source;
|
|
// if(_mProject.IsPart(source)) source = _mProject.SplitTaskOf(source);
|
|
// if (this.TryGetRow(source, out from))
|
|
// _mProject.Move(source, e.Row - from);
|
|
//}
|
|
//else
|
|
{
|
|
// displace horizontally
|
|
var start = e.Source.Start + delta;
|
|
var parent = _mProject.DirectPrecedentsOf(e.Source);
|
|
if (parent != null && parent.Count() > 0)
|
|
{
|
|
var parentTask = parent.First();
|
|
if (start < parentTask.End)
|
|
{
|
|
start = parentTask.End;
|
|
}
|
|
}
|
|
|
|
_mProject.SetStart(e.Source, start);
|
|
}
|
|
}
|
|
//// 屏蔽拖动到其他Task
|
|
//else // have drop target
|
|
//{
|
|
// if (Control.ModifierKeys.HasFlag(Keys.Shift))
|
|
// {
|
|
// _mProject.Relate(e.Target, e.Source);
|
|
// }
|
|
// else if (Control.ModifierKeys.HasFlag(Keys.Alt))
|
|
// {
|
|
// var source = e.Source;
|
|
// if (_mProject.IsPart(source)) source = _mProject.SplitTaskOf(source);
|
|
// if (_mProject.ParentOf(source) == e.Target)
|
|
// {
|
|
// _mProject.Ungroup(e.Target, e.Source);
|
|
// }
|
|
// else
|
|
// {
|
|
// _mProject.Unrelate(e.Target, source);
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// //_mProject.Group(e.Target, e.Source);
|
|
// }
|
|
//}
|
|
}
|
|
|
|
//// 屏蔽右键拖动
|
|
//else if (e.Button == System.Windows.Forms.MouseButtons.Right)
|
|
//{
|
|
// if (e.Target == null)
|
|
// {
|
|
// var duration = e.Source.Duration + delta;
|
|
// _mProject.SetDuration(e.Source, duration);
|
|
// }
|
|
// else // have target then we do a join
|
|
// {
|
|
// _mProject.Join(e.Target, e.Source);
|
|
// }
|
|
//}
|
|
if (TaskMouseDrop != null && delta > 0.1)
|
|
TaskMouseDrop(this, e);
|
|
_mOverlay.Clear();
|
|
this.Invalidate();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Raises the TaskMouseClick event
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual void OnTaskMouseClick(TaskMouseEventArgs e)
|
|
{
|
|
if (TaskMouseClick != null)
|
|
TaskMouseClick(this, e);
|
|
|
|
if (e.Button == System.Windows.Forms.MouseButtons.Left)
|
|
{
|
|
if (ModifierKeys.HasFlag(Keys.Control))
|
|
{
|
|
_mSelectedTasks.Add(e.Task);
|
|
}
|
|
else
|
|
{
|
|
OnTaskDeselecting(e);
|
|
_mSelectedTasks.Add(e.Task);
|
|
}
|
|
|
|
OnTaskSelected(e);
|
|
}
|
|
else if (e.Button == System.Windows.Forms.MouseButtons.Middle)
|
|
{
|
|
if (ModifierKeys.HasFlag(Keys.Shift))
|
|
{
|
|
var newtask = CreateTaskDelegate();
|
|
_mProject.Add(newtask);
|
|
_mProject.SetStart(newtask, e.Task.Start);
|
|
_mProject.SetDuration(newtask, 5);
|
|
if (_mProject.IsPart(e.Task))
|
|
_mProject.Move(newtask,
|
|
_mProject.IndexOf(_mProject.SplitTaskOf(e.Task)) + 1 - _mProject.IndexOf(newtask));
|
|
else _mProject.Move(newtask, _mProject.IndexOf(e.Task) + 1 - _mProject.IndexOf(newtask));
|
|
}
|
|
else if (Control.ModifierKeys.HasFlag(Keys.Alt))
|
|
_mProject.Delete(e.Task);
|
|
}
|
|
|
|
this.Invalidate();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises the TaskMouseDoubleClick event
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual void OnTaskMouseDoubleClick(TaskMouseEventArgs e)
|
|
{
|
|
if (TaskMouseDoubleClick != null)
|
|
TaskMouseDoubleClick(this, e);
|
|
|
|
if (e.Button == System.Windows.Forms.MouseButtons.Left)
|
|
{
|
|
e.Task.IsCollapsed = !e.Task.IsCollapsed;
|
|
}
|
|
else if (e.Button == System.Windows.Forms.MouseButtons.Right)
|
|
{
|
|
int duration = (int) ((_mViewport.DeviceToWorldCoord(e.Location).X - e.Rectangle.Left) / this.BarWidth);
|
|
if (_mProject.IsPart(e.Task)) _mProject.Split(e.Task, new Task(), duration);
|
|
else _mProject.Split(e.Task, CreateTaskDelegate(), CreateTaskDelegate(), duration);
|
|
}
|
|
|
|
this.Invalidate();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises the TaskSelected event
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual void OnTaskSelected(TaskMouseEventArgs e)
|
|
{
|
|
if (TaskSelected != null)
|
|
TaskSelected(this, e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises the TaskDeselecting event
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual void OnTaskDeselecting(TaskMouseEventArgs e)
|
|
{
|
|
if (TaskDeselecting != null)
|
|
TaskDeselecting(this, e);
|
|
|
|
// deselect all tasks
|
|
_mSelectedTasks.Clear();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises the PaintOverlay event
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual void OnPaintOverlay(ChartPaintEventArgs e)
|
|
{
|
|
if (this.PaintOverlay != null)
|
|
PaintOverlay(this, e);
|
|
}
|
|
|
|
#endregion Chart Events
|
|
|
|
#region OverlayPainter
|
|
|
|
private ChartOverlay _mOverlay = new ChartOverlay();
|
|
|
|
class ChartOverlay
|
|
{
|
|
public void Paint(ChartPaintEventArgs e)
|
|
{
|
|
var g = e.Graphics;
|
|
var chart = e.Chart;
|
|
|
|
// dragging outline / trail
|
|
if (DraggedRect != RectangleF.Empty)
|
|
g.DrawRectangle(Pens.Red, DraggedRect);
|
|
|
|
// insertion indicator line
|
|
if (Row != int.MinValue)
|
|
{
|
|
float y = e.Chart._ChartRowToChartCoord(Row) + e.Chart.BarHeight / 2.0f;
|
|
g.DrawLine(Pens.CornflowerBlue, new PointF(0, y), new PointF(e.Chart.Width, y));
|
|
}
|
|
|
|
// tool tip
|
|
if (_mToolTipMouse != Point.Empty && _mToolTipText != string.Empty)
|
|
{
|
|
var size = g.MeasureString(_mToolTipText, chart.Font).ToSize();
|
|
var tooltiprect = new RectangleF(_mToolTipMouse, size);
|
|
tooltiprect.Offset(0, -tooltiprect.Height);
|
|
var textstart = new PointF(tooltiprect.Left, tooltiprect.Top);
|
|
tooltiprect.Inflate(5, 5);
|
|
g.FillRectangle(Brushes.LightYellow, tooltiprect);
|
|
g.DrawString(_mToolTipText, chart.Font, Brushes.Black, textstart);
|
|
}
|
|
}
|
|
|
|
public void ShowToolTip(PointF worldcoord, string text)
|
|
{
|
|
_mToolTipMouse = worldcoord;
|
|
_mToolTipText = text;
|
|
}
|
|
|
|
public void HideToolTip()
|
|
{
|
|
_mToolTipMouse = Point.Empty;
|
|
_mToolTipText = string.Empty;
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
DraggedRect = RectangleF.Empty;
|
|
Row = int.MinValue;
|
|
}
|
|
|
|
private PointF _mToolTipMouse = PointF.Empty;
|
|
private string _mToolTipText = string.Empty;
|
|
public RectangleF DraggedRect = RectangleF.Empty;
|
|
public int Row = int.MinValue;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private Helper Methods
|
|
|
|
private Task _GetTaskUnderMouse(Point mouse)
|
|
{
|
|
var chartcoord = _mViewport.DeviceToWorldCoord(mouse);
|
|
|
|
if (!_mHeaderInfo.H1Rect.Contains(chartcoord)
|
|
&& !_mHeaderInfo.H2Rect.Contains(chartcoord))
|
|
{
|
|
foreach (var task in _mChartTaskHitRects.Keys)
|
|
{
|
|
if (_mChartTaskHitRects[task].Contains(chartcoord))
|
|
return task;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private bool _GetIsPlayMaskDragDropUnderMouse(Point mouse)
|
|
{
|
|
var chartcoord = _mViewport.DeviceToWorldCoord(mouse);
|
|
|
|
//if (!_mHeaderInfo.H1Rect.Contains(chartcoord)
|
|
// && !_mHeaderInfo.H2Rect.Contains(chartcoord))
|
|
//{
|
|
// foreach (var task in _mChartTaskHitRects.Keys)
|
|
// {
|
|
// if (_mChartTaskHitRects[task].Contains(chartcoord))
|
|
// return task;
|
|
// }
|
|
//}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
private int _GetDeviceColumnUnderMouse(Point mouse)
|
|
{
|
|
var worldcoord = _mViewport.DeviceToWorldCoord(mouse);
|
|
|
|
return _mHeaderInfo.Columns.Select((x, i) => new {x, i}).FirstOrDefault(x => x.x.Contains(worldcoord)).i;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert view Y coordinate to zero based row number
|
|
/// </summary>
|
|
/// <param name="y"></param>
|
|
/// <returns></returns>
|
|
private int _DeviceCoordToChartRow(float y)
|
|
{
|
|
y = _mViewport.DeviceToWorldCoord(new PointF(0, y)).Y;
|
|
var row = (int) ((y - this.BarSpacing - this.HeaderOneHeight) / this.BarSpacing);
|
|
return row < 0 ? 0 : row;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert world Y coordinate to zero-based row number
|
|
/// </summary>
|
|
/// <param name="y"></param>
|
|
/// <returns></returns>
|
|
private int _ChartCoordToChartRow(float y)
|
|
{
|
|
var row = (int) ((y - this.HeaderTwoHeight - this.HeaderOneHeight) / this.BarSpacing);
|
|
return row < 0 ? 0 : row;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert zero based row number to client Y coordinates
|
|
/// </summary>
|
|
/// <param name="row"></param>
|
|
/// <returns></returns>
|
|
private float _ChartRowToChartCoord(int row)
|
|
{
|
|
return row * this.BarSpacing + this.HeaderTwoHeight + this.HeaderOneHeight;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generate the task models and resize the world accordingly
|
|
/// </summary>
|
|
public void _GenerateModels()
|
|
{
|
|
// Clear Models
|
|
_mChartTaskRects.Clear();
|
|
_mChartTaskHitRects.Clear();
|
|
_mChartSlackRects.Clear();
|
|
_mChartTaskPartRects.Clear();
|
|
|
|
var pHeight = this.Parent == null ? this.Width : this.Parent.Height;
|
|
var pWidth = this.Parent == null ? this.Height : this.Parent.Width;
|
|
|
|
// loop over the tasks and pick up items
|
|
float end = int.MinValue;
|
|
int row = 0;
|
|
foreach (var task in _mProject.Tasks)
|
|
{
|
|
if (!_mProject.AncestorsOf(task).Any(x => x.IsCollapsed))
|
|
{
|
|
int y_coord = row * this.BarSpacing + this.HeaderTwoHeight + this.HeaderOneHeight +
|
|
(this.BarSpacing - this.BarHeight) / 2;
|
|
RectangleF taskRect;
|
|
|
|
// Compute task rectangle
|
|
//taskRect = new RectangleF(task.Start * this.BarWidth + this.BarWidth / 2, y_coord, task.Duration * this.BarWidth, this.BarHeight);
|
|
//wangdequan 20200531 改成 task X从 0点开始
|
|
taskRect = new RectangleF(task.Start * this.BarWidth / HeaderScale, y_coord,
|
|
task.Duration * this.BarWidth / HeaderScale, this.BarHeight);
|
|
_mChartTaskRects.Add(task, taskRect);
|
|
|
|
if (!_mProject.IsSplit(task))
|
|
{
|
|
// Add normal Task Rectangles to hitRect collection for hit testing
|
|
_mChartTaskHitRects.Add(task, taskRect);
|
|
}
|
|
else // Compute task part rectangles if task is a split task
|
|
{
|
|
var parts = new List<KeyValuePair<Task, RectangleF>>();
|
|
_mChartTaskPartRects.Add(task, parts);
|
|
foreach (var part in _mProject.PartsOf(task))
|
|
{
|
|
//wangdequan 20200513
|
|
taskRect = new RectangleF(part.Start * this.BarWidth, y_coord,
|
|
part.Duration * this.BarWidth, this.BarHeight);
|
|
//taskRect = new RectangleF(part.Start * this.BarWidth + this.BarWidth / 2, y_coord, part.Duration * this.BarWidth, this.BarHeight);
|
|
parts.Add(new KeyValuePair<Task, RectangleF>(part, taskRect));
|
|
|
|
// Parts are mouse enabled, add to hitRect collection
|
|
_mChartTaskHitRects.Add(part, taskRect);
|
|
}
|
|
}
|
|
|
|
// Compute Slack Rectangles
|
|
if (this.ShowSlack)
|
|
{
|
|
var slackRect = new RectangleF(task.End * this.BarWidth + this.BarWidth / 2, y_coord,
|
|
task.Slack * this.BarWidth, this.BarHeight);
|
|
_mChartSlackRects.Add(task, slackRect);
|
|
}
|
|
|
|
// Find maximum end time
|
|
if (task.End > end) end = task.End;
|
|
|
|
row++;
|
|
}
|
|
}
|
|
|
|
row += 5;
|
|
_mViewport.WorldHeight = Math.Max(pHeight, row * this.BarSpacing + this.BarHeight);
|
|
_mViewport.WorldWidth = Math.Max(pWidth, end * this.BarWidth + 200);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generate the task models and resize the world accordingly wangdequan 20200531
|
|
/// </summary>
|
|
private void _GenerateModels_DT()
|
|
{
|
|
// Clear Models
|
|
_mChartTaskRects.Clear();
|
|
_mChartTaskHitRects.Clear();
|
|
_mChartSlackRects.Clear();
|
|
_mChartTaskPartRects.Clear();
|
|
|
|
var pHeight = this.Parent == null ? this.Width : this.Parent.Height;
|
|
var pWidth = this.Parent == null ? this.Height : this.Parent.Width;
|
|
|
|
// loop over the tasks and pick up items
|
|
float end = int.MinValue;
|
|
int row = 0;
|
|
foreach (var task in _mProject.Tasks)
|
|
{
|
|
if (!_mProject.AncestorsOf(task).Any(x => x.IsCollapsed))
|
|
{
|
|
int y_coord = row * this.BarSpacing + this.HeaderTwoHeight + this.HeaderOneHeight +
|
|
(this.BarSpacing - this.BarHeight) / 2;
|
|
RectangleF taskRect;
|
|
|
|
// Compute task rectangle
|
|
//taskRect = new RectangleF(task.Start * this.BarWidth + this.BarWidth / 2, y_coord, task.Duration * this.BarWidth, this.BarHeight);
|
|
//wangdequan 20200531 改成 task X从 0点开始
|
|
taskRect = new RectangleF(task.Start * this.BarWidth, y_coord, task.Duration * this.BarWidth,
|
|
this.BarHeight);
|
|
_mChartTaskRects.Add(task, taskRect);
|
|
|
|
if (!_mProject.IsSplit(task))
|
|
{
|
|
// Add normal Task Rectangles to hitRect collection for hit testing
|
|
_mChartTaskHitRects.Add(task, taskRect);
|
|
}
|
|
else // Compute task part rectangles if task is a split task
|
|
{
|
|
var parts = new List<KeyValuePair<Task, RectangleF>>();
|
|
_mChartTaskPartRects.Add(task, parts);
|
|
foreach (var part in _mProject.PartsOf(task))
|
|
{
|
|
//wangdequan 20200513
|
|
taskRect = new RectangleF(part.Start * this.BarWidth, y_coord,
|
|
part.Duration * this.BarWidth, this.BarHeight);
|
|
//taskRect = new RectangleF(part.Start * this.BarWidth + this.BarWidth / 2, y_coord, part.Duration * this.BarWidth, this.BarHeight);
|
|
parts.Add(new KeyValuePair<Task, RectangleF>(part, taskRect));
|
|
|
|
// Parts are mouse enabled, add to hitRect collection
|
|
_mChartTaskHitRects.Add(part, taskRect);
|
|
}
|
|
}
|
|
|
|
// Compute Slack Rectangles
|
|
if (this.ShowSlack)
|
|
{
|
|
var slackRect = new RectangleF(task.End * this.BarWidth + this.BarWidth / 2, y_coord,
|
|
task.Slack * this.BarWidth, this.BarHeight);
|
|
_mChartSlackRects.Add(task, slackRect);
|
|
}
|
|
|
|
// Find maximum end time
|
|
if (task.End > end) end = task.End;
|
|
|
|
row++;
|
|
}
|
|
}
|
|
|
|
row += 5;
|
|
_mViewport.WorldHeight = Math.Max(pHeight, row * this.BarSpacing + this.BarHeight);
|
|
_mViewport.WorldWidth = Math.Max(pWidth, end * this.BarWidth + 200);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generate Header rectangles and dates wangdequan
|
|
/// </summary>
|
|
private void _GenerateHeaders_DT()
|
|
{
|
|
// only generate the necessary headers by determining of current viewport location
|
|
var h1Rect = new RectangleF(_mViewport.X, _mViewport.Y, _mViewport.Rectangle.Width, this.HeaderOneHeight);
|
|
var h2Rect = new RectangleF(h1Rect.Left, h1Rect.Bottom, _mViewport.Rectangle.Width, this.HeaderTwoHeight);
|
|
var h1LabelRects = new List<RectangleF>();
|
|
var h2LabelRects = new List<RectangleF>();
|
|
var columns = new List<RectangleF>();
|
|
var h1labels = new List<string>();
|
|
var h2labels = new List<string>();
|
|
var dates = new List<DateTime>();
|
|
var dates_DT = new List<string>();
|
|
|
|
// generate columns across the viewport area
|
|
int curStartIndex = (int) (_mViewport.X / this.BarWidth);
|
|
string lable1;
|
|
//var curDate = __CalculateViewportStart();
|
|
var h2LabelRect_Y = _mViewport.Y + this.HeaderOneHeight;
|
|
var columns_Y = h2LabelRect_Y + this.HeaderTwoHeight;
|
|
for (float x = (_mViewport.X - _mViewport.X % this.BarWidth);
|
|
x < _mViewport.Rectangle.Right;
|
|
x += this.BarWidth)
|
|
{
|
|
float d = curStartIndex * HeaderScale * 1000f;
|
|
lable1 = (d / 1000f).ToString();
|
|
dates_DT.Add(lable1);
|
|
//dates.Add(curDate);
|
|
h2LabelRects.Add(new RectangleF(x, h2LabelRect_Y, this.BarWidth, this.HeaderTwoHeight));
|
|
columns.Add(new RectangleF(x, columns_Y, this.BarWidth, _mViewport.Rectangle.Height));
|
|
curStartIndex = curStartIndex + 1;
|
|
}
|
|
|
|
_mHeaderInfo.H1Rect = h1Rect;
|
|
_mHeaderInfo.H2Rect = h2Rect;
|
|
_mHeaderInfo.H1LabelRects = h1LabelRects;
|
|
_mHeaderInfo.H2LabelRects = h2LabelRects;
|
|
_mHeaderInfo.Columns = columns;
|
|
_mHeaderInfo.Dates = dates;
|
|
_mHeaderInfo.Dates_DT = dates_DT;
|
|
}
|
|
|
|
private void _GenerateHeaders_DT_back()
|
|
{
|
|
// only generate the necessary headers by determining of current viewport location
|
|
var h1Rect = new RectangleF(_mViewport.X, _mViewport.Y, _mViewport.Rectangle.Width, this.HeaderOneHeight);
|
|
var h2Rect = new RectangleF(h1Rect.Left, h1Rect.Bottom, _mViewport.Rectangle.Width, this.HeaderTwoHeight);
|
|
var h1LabelRects = new List<RectangleF>();
|
|
var h2LabelRects = new List<RectangleF>();
|
|
var columns = new List<RectangleF>();
|
|
var h1labels = new List<string>();
|
|
var h2labels = new List<string>();
|
|
var dates = new List<DateTime>();
|
|
var dates_DT = new List<string>();
|
|
|
|
// generate columns across the viewport area
|
|
int curStartIndex = (int) (_mViewport.X / this.BarWidth);
|
|
string lable1;
|
|
//var curDate = __CalculateViewportStart();
|
|
var h2LabelRect_Y = _mViewport.Y + this.HeaderOneHeight;
|
|
var columns_Y = h2LabelRect_Y + this.HeaderTwoHeight;
|
|
for (float x = (_mViewport.X - _mViewport.X % this.BarWidth);
|
|
x < _mViewport.Rectangle.Right;
|
|
x += this.BarWidth)
|
|
{
|
|
float d = curStartIndex * HeaderScale * 1000f;
|
|
lable1 = (d / 1000f).ToString();
|
|
dates_DT.Add(lable1);
|
|
//dates.Add(curDate);
|
|
h2LabelRects.Add(new RectangleF(x, h2LabelRect_Y, this.BarWidth, this.HeaderTwoHeight));
|
|
columns.Add(new RectangleF(x, columns_Y, this.BarWidth, _mViewport.Rectangle.Height));
|
|
curStartIndex = curStartIndex + 1;
|
|
}
|
|
|
|
_mHeaderInfo.H1Rect = h1Rect;
|
|
_mHeaderInfo.H2Rect = h2Rect;
|
|
_mHeaderInfo.H1LabelRects = h1LabelRects;
|
|
_mHeaderInfo.H2LabelRects = h2LabelRects;
|
|
_mHeaderInfo.Columns = columns;
|
|
_mHeaderInfo.Dates = dates;
|
|
_mHeaderInfo.Dates_DT = dates_DT;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generate Header rectangles and dates
|
|
/// </summary>
|
|
private void _GenerateHeaders()
|
|
{
|
|
// only generate the necessary headers by determining of current viewport location
|
|
var h1Rect = new RectangleF(_mViewport.X, _mViewport.Y, _mViewport.Rectangle.Width, this.HeaderOneHeight);
|
|
var h2Rect = new RectangleF(h1Rect.Left, h1Rect.Bottom, _mViewport.Rectangle.Width, this.HeaderTwoHeight);
|
|
var h1LabelRects = new List<RectangleF>();
|
|
var h2LabelRects = new List<RectangleF>();
|
|
var columns = new List<RectangleF>();
|
|
var h1labels = new List<string>();
|
|
var h2labels = new List<string>();
|
|
var dates = new List<DateTime>();
|
|
|
|
// generate columns across the viewport area
|
|
var curDate = __CalculateViewportStart();
|
|
var h2LabelRect_Y = _mViewport.Y + this.HeaderOneHeight;
|
|
var columns_Y = h2LabelRect_Y + this.HeaderTwoHeight;
|
|
for (float x = (_mViewport.X - _mViewport.X % this.BarWidth);
|
|
x < _mViewport.Rectangle.Right;
|
|
x += this.BarWidth)
|
|
{
|
|
dates.Add(curDate);
|
|
h2LabelRects.Add(new RectangleF(x, h2LabelRect_Y, this.BarWidth, this.HeaderTwoHeight));
|
|
columns.Add(new RectangleF(x, columns_Y, this.BarWidth, _mViewport.Rectangle.Height));
|
|
|
|
__NextColumn(ref curDate);
|
|
}
|
|
|
|
_mHeaderInfo.H1Rect = h1Rect;
|
|
_mHeaderInfo.H2Rect = h2Rect;
|
|
_mHeaderInfo.H1LabelRects = h1LabelRects;
|
|
_mHeaderInfo.H2LabelRects = h2LabelRects;
|
|
_mHeaderInfo.Columns = columns;
|
|
_mHeaderInfo.Dates = dates;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Calculate the date in the first visible column in the viewport
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private DateTime __CalculateViewportStart()
|
|
{
|
|
int vpTime = (int) (_mViewport.X / this.BarWidth);
|
|
if (_mProject.TimeScale == TimeScale.Day)
|
|
{
|
|
return _mProject.Start.AddDays(vpTime);
|
|
}
|
|
else /* if (_mProject.TimeScale == TimeScale.Week) */
|
|
{
|
|
var startWeek = _mProject.Start.AddDays(-(int) _mProject.Start.DayOfWeek);
|
|
return startWeek.AddDays(vpTime * 7);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Integrates the current DateTime by one column of TimeScale
|
|
/// </summary>
|
|
/// <param name="current"></param>
|
|
private void __NextColumn(ref DateTime current)
|
|
{
|
|
if (_mProject.TimeScale == TimeScale.Day)
|
|
current = current.AddDays(1);
|
|
else // if (_mProject.TimeScale == TimeScale.Week)
|
|
current = current.AddDays(7);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Draw the Chart using the specified graphics
|
|
/// </summary>
|
|
private void _Draw(Graphics graphics, Rectangle clipRect)
|
|
{
|
|
graphics.Clear(Color.White);
|
|
|
|
int row = 0;
|
|
if (_mProject != null)
|
|
{
|
|
HeaderScale = ZoomScaleList[ZoomScaleIndex];
|
|
|
|
// generate rectangles
|
|
_GenerateModels();
|
|
|
|
//wangdequan 20200531
|
|
//_GenerateHeaders();
|
|
|
|
_GenerateHeaders_DT();
|
|
|
|
// set model view matrix
|
|
graphics.Transform = _mViewport.Projection;
|
|
|
|
// draw columns in the background
|
|
_DrawColumns(graphics);
|
|
|
|
// draw bar charts
|
|
row = this._DrawTasks(graphics, clipRect);
|
|
|
|
// draw predecessor arrows
|
|
if (this.ShowRelations)
|
|
this._DrawPredecessorLines(graphics);
|
|
|
|
// draw the header
|
|
_DrawHeader(graphics, clipRect);
|
|
|
|
// Paint overlays
|
|
ChartPaintEventArgs paintargs = new ChartPaintEventArgs(graphics, clipRect, this);
|
|
OnPaintOverlay(paintargs);
|
|
|
|
_mOverlay.Paint(paintargs);
|
|
}
|
|
else
|
|
{
|
|
// nothing to draw
|
|
}
|
|
|
|
//播放时，绘制播放线
|
|
if (_mProject.IsPlaye)
|
|
{
|
|
OnPaint_PlaySlider(graphics);
|
|
}
|
|
|
|
// flush
|
|
graphics.Flush();
|
|
}
|
|
|
|
private void _DrawHeader(Graphics graphics, Rectangle clipRect)
|
|
{
|
|
var info = _mHeaderInfo;
|
|
var viewRect = _mViewport.Rectangle;
|
|
var e = new HeaderPaintEventArgs(graphics, clipRect, this, this.Font, this.HeaderFormat);
|
|
if (PaintHeader != null)
|
|
PaintHeader(this, e);
|
|
|
|
// Draw header backgrounds
|
|
var gradient = new System.Drawing.Drawing2D.LinearGradientBrush(info.H1Rect, e.Format.GradientLight,
|
|
e.Format.GradientDark, System.Drawing.Drawing2D.LinearGradientMode.Vertical);
|
|
graphics.FillRectangles(gradient, new RectangleF[] {info.H1Rect, info.H2Rect});
|
|
//graphics.DrawRectangles(e.Format.Border, new RectangleF[] { info.H1Rect, info.H2Rect });
|
|
|
|
// draw h2 labels
|
|
string label = string.Empty;
|
|
System.Globalization.GregorianCalendar cal =
|
|
new System.Globalization.GregorianCalendar(System.Globalization.GregorianCalendarTypes.Localized);
|
|
for (int i = 0; i < info.H2LabelRects.Count; i++)
|
|
{
|
|
var h2labelrect = info.H2LabelRects[i];
|
|
label = info.Dates_DT[i];
|
|
//var date = info.Dates[i];
|
|
//if (this.TimeScaleDisplay == GanttChart.TimeScaleDisplay.DayOfWeek)
|
|
// label = Chart.ShortDays[date.DayOfWeek];
|
|
//else if (this.TimeScaleDisplay == GanttChart.TimeScaleDisplay.DayOfMonth)
|
|
// label = date.Day.ToString();
|
|
//else if (this.TimeScaleDisplay == GanttChart.TimeScaleDisplay.WeekOfYear)
|
|
// label = cal.GetWeekOfYear(date, System.Globalization.CalendarWeekRule.FirstFullWeek, DayOfWeek.Sunday).ToString();
|
|
//wangdequan 2020-05-31
|
|
var h2textrect = _TextAlignLeftMiddle(graphics, h2labelrect, label, e.Font);
|
|
// h2textrect = _TextAlignCenterMiddle(graphics, h2labelrect, label, e.Font);
|
|
graphics.DrawString(label, e.Font, e.Format.Color, h2textrect);
|
|
|
|
// draw h1 label and rects wangdequan
|
|
//__DrawHeaderOne(graphics, i, e, h2textrect);
|
|
}
|
|
|
|
//// draw "Now" line
|
|
//float xf = (_mProject.Now + 0.5f) * BarWidth;
|
|
//var pen = new Pen(e.Format.Border.Color);
|
|
//pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
|
|
//graphics.DrawLine(pen, new PointF(xf, _mViewport.Y), new PointF(xf, _mViewport.Rectangle.Bottom));
|
|
//_mProject.Now = 5;
|
|
|
|
|
|
//float xf1 = _mProject.NowIndexXf;
|
|
|
|
//pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
|
|
//pen.Width = 2;
|
|
//graphics.DrawLine(pen, new PointF(xf1, _mViewport.Y), new PointF(xf1, _mViewport.Rectangle.Bottom));
|
|
}
|
|
|
|
private void _DrawColumns(Graphics graphics)
|
|
{
|
|
// draw column lines
|
|
graphics.DrawRectangles(this.HeaderFormat.Border, _mHeaderInfo.Columns.ToArray());
|
|
|
|
// fill weekend columns
|
|
//if (_mProject.TimeScale == TimeScale.Day)
|
|
//{
|
|
// for (int i = 0; i < _mHeaderInfo.Dates.Count; i++)
|
|
// {
|
|
// var date = _mHeaderInfo.Dates[i];
|
|
// // highlight weekends for day time scale
|
|
// if (date.DayOfWeek == DayOfWeek.Sunday || date.DayOfWeek == DayOfWeek.Saturday)
|
|
// {
|
|
// var pattern = new System.Drawing.Drawing2D.HatchBrush(System.Drawing.Drawing2D.HatchStyle.Percent20, this.HeaderFormat.Border.Color, Color.Transparent);
|
|
// graphics.FillRectangle(pattern, _mHeaderInfo.Columns[i]);
|
|
// }
|
|
// }
|
|
//}
|
|
}
|
|
|
|
private void __DrawHeaderOne(Graphics graphics, int columnIndex, HeaderPaintEventArgs e, RectangleF h2textrect)
|
|
{
|
|
var info = _mHeaderInfo;
|
|
var h2labelrect = info.H2LabelRects[columnIndex];
|
|
var date = info.Dates[columnIndex];
|
|
var h1labelrect = RectangleF.Empty;
|
|
|
|
// draw h1 labels for day of week
|
|
if (this.TimeScaleDisplay == GanttChart.TimeScaleDisplay.DayOfWeek)
|
|
{
|
|
// put a date on every sunday
|
|
if (date.DayOfWeek == DayOfWeek.Sunday)
|
|
{
|
|
var columnsinlabel = _mProject.TimeScale == TimeScale.Day ? 7 : 1;
|
|
h1labelrect = new RectangleF(h2labelrect.X, _mViewport.Y, columnsinlabel * BarWidth,
|
|
this.HeaderOneHeight);
|
|
var h1textrect = _TextAlignLeftMiddle(graphics, h1labelrect, date.ToShortDateString(), e.Font,
|
|
h2textrect.X - h2labelrect.X);
|
|
graphics.DrawString(date.ToString(this.FullDateStringFormat), e.Font, e.Format.Color, h1textrect);
|
|
__DrawMarker(graphics, (h2labelrect.Left + h2labelrect.Right) / 2f,
|
|
_mHeaderInfo.H1Rect.Bottom - 5f);
|
|
}
|
|
}
|
|
else if (this.TimeScaleDisplay == GanttChart.TimeScaleDisplay.DayOfMonth ||
|
|
this.TimeScaleDisplay == GanttChart.TimeScaleDisplay.WeekOfYear)
|
|
{
|
|
// put a month
|
|
if (columnIndex == 0 || (date.Month != info.Dates[columnIndex - 1].Month))
|
|
{
|
|
var h1label = _mProject.TimeScale == TimeScale.Day
|
|
? date.ToString("MMMM yyyy")
|
|
: date.ToString("MMM yy");
|
|
var columnsinlabel = _mProject.TimeScale == TimeScale.Day
|
|
? DateTime.DaysInMonth(date.Year, date.Month)
|
|
: Enumerable.Range(1, DateTime.DaysInMonth(date.Year, date.Month))
|
|
.Select(day => new DateTime(date.Year, date.Month, day))
|
|
.Count(d => d.DayOfWeek == DayOfWeek.Sunday);
|
|
if (columnIndex == 0)
|
|
{
|
|
var leftcolshiftcount = _mProject.TimeScale == TimeScale.Day ? (date.Day - 1) : date.Day / 7;
|
|
h1labelrect = new RectangleF(h2labelrect.X - leftcolshiftcount * BarWidth, _mViewport.Y,
|
|
columnsinlabel * BarWidth, this.HeaderOneHeight);
|
|
}
|
|
else
|
|
h1labelrect = new RectangleF(h2labelrect.X, _mViewport.Y, columnsinlabel * BarWidth,
|
|
this.HeaderOneHeight);
|
|
|
|
var h1textrect = _TextAlignCenterMiddle(graphics, h1labelrect, h1label, e.Font);
|
|
graphics.DrawString(h1label, e.Font, e.Format.Color, h1textrect);
|
|
graphics.DrawRectangle(e.Format.Border, h1labelrect);
|
|
}
|
|
}
|
|
|
|
// ****************************************
|
|
// Add the H1 Label rect to our header info
|
|
// *****************************************
|
|
_mHeaderInfo.H1LabelRects.Add(h1labelrect);
|
|
}
|
|
|
|
private void __DrawMarker(Graphics graphics, float offsetX, float offsetY)
|
|
{
|
|
var marker = _Marker.Select(p => new PointF(p.X + offsetX, p.Y + offsetY)).ToArray();
|
|
graphics.FillPolygon(Brushes.LightGoldenrodYellow, marker);
|
|
graphics.DrawPolygon(new Pen(SystemColors.ButtonShadow), marker);
|
|
}
|
|
|
|
private int _DrawTasks(Graphics graphics, Rectangle clipRect)
|
|
{
|
|
var viewRect = _mViewport.Rectangle;
|
|
int row = 0;
|
|
var crit_task_set = new HashSet<Task>(_mProject.CriticalPaths.SelectMany(x => x));
|
|
var pen = new Pen(Color.Gray);
|
|
float labelMargin = this.BarWidth / 2.0f + 3.0f;
|
|
pen.DashStyle = DashStyle.Dot;
|
|
TaskPaintEventArgs e;
|
|
foreach (var task in _mChartTaskRects.Keys)
|
|
{
|
|
// Get the taskrect
|
|
var taskrect = _mChartTaskRects[task];
|
|
|
|
// Only begin drawing when the taskrect is to the left of the clipRect's right edge
|
|
if (taskrect.Left <= viewRect.Right)
|
|
{
|
|
// Crtical Path
|
|
bool critical = crit_task_set.Contains(task);
|
|
if (critical)
|
|
e = new TaskPaintEventArgs(graphics, clipRect, this, task, row, critical, this.Font,
|
|
this.CriticalTaskFormat);
|
|
else
|
|
e = new TaskPaintEventArgs(graphics, clipRect, this, task, row, critical, this.Font,
|
|
this.TaskFormat);
|
|
if (PaintTask != null) PaintTask(this, e);
|
|
|
|
if (viewRect.IntersectsWith(taskrect))
|
|
{
|
|
if (_mProject.IsSplit(task))
|
|
{
|
|
__DrawTaskParts(graphics, e, task, pen);
|
|
}
|
|
else
|
|
{
|
|
__DrawRegularTaskAndGroup(graphics, e, task, taskrect);
|
|
}
|
|
}
|
|
|
|
// write text
|
|
if (this.ShowTaskLabels && task.Name != string.Empty)
|
|
{
|
|
var name = task.Name;
|
|
var txtrect = _TextAlignLeftMiddle(graphics, taskrect, name, e.Font, labelMargin);
|
|
txtrect.Offset(taskrect.Width, 0);
|
|
if (viewRect.IntersectsWith(txtrect))
|
|
{
|
|
graphics.DrawString(name, e.Font, e.Format.Color, txtrect);
|
|
}
|
|
}
|
|
|
|
// draw slack
|
|
if (this.ShowSlack && task.Complete < 1.0f)
|
|
{
|
|
var slackrect = _mChartSlackRects[task];
|
|
if (viewRect.IntersectsWith(slackrect))
|
|
graphics.FillRectangle(e.Format.SlackFill, slackrect);
|
|
}
|
|
}
|
|
|
|
row++;
|
|
}
|
|
|
|
return row;
|
|
}
|
|
|
|
private void _DrawPredecessorLines(Graphics graphics)
|
|
{
|
|
var viewRect = _mViewport.Rectangle;
|
|
RectangleF clipRectF = new RectangleF(viewRect.X, viewRect.Y, viewRect.Width, viewRect.Height);
|
|
foreach (var p in _mProject.Precedents)
|
|
{
|
|
var precedent = p;
|
|
IEnumerable<Task> dependants = _mProject.DirectDependantsOf(precedent);
|
|
|
|
// check with _mTaskRects that the precedent was drawn; this is needed to connect the lines
|
|
if (_mChartTaskRects.ContainsKey(precedent))
|
|
{
|
|
foreach (var d in dependants)
|
|
{
|
|
var dependant = d;
|
|
|
|
// check with _mTaskRects that the dependant was drawn; this is needed to connect the lines
|
|
if (_mChartTaskRects.ContainsKey(dependant))
|
|
{
|
|
var prect = _mChartTaskRects[precedent];
|
|
var srect = _mChartTaskRects[dependant];
|
|
if (precedent.End <= dependant.Start)
|
|
{
|
|
/*
|
|
var p1 = new PointF(prect.Right, prect.Top + prect.Height / 2.0f);
|
|
var p2 = new PointF(srect.Left - BarWidth / 2, prect.Top + prect.Height / 2.0f);
|
|
var p3 = new PointF(srect.Left - BarWidth / 2, srect.Top + srect.Height / 2.0f);
|
|
var p4 = new PointF(srect.Left, srect.Top + srect.Height / 2.0f);
|
|
var size = new SizeF(Math.Abs(p4.X - p1.X), Math.Abs(p4.Y - p1.Y));
|
|
var linerect = p1.Y < p4.Y ? new RectangleF(p1, size) : new RectangleF(new PointF(p1.X, p1.Y - size.Height), size);
|
|
*/
|
|
//var p1 = new PointF(prect.Right, prect.Top + prect.Height / 2.0f);
|
|
//var p2 = new PointF(prect.Right + BarWidth / 2, prect.Top + prect.Height / 2.0f);
|
|
//var p3 = new PointF(prect.Right + BarWidth / 2, srect.Top + srect.Height / 2.0f);
|
|
//var p4 = new PointF(srect.Left, srect.Top + srect.Height / 2.0f);
|
|
|
|
//wangdequan 20200602
|
|
var p1 = new PointF(prect.Right, prect.Top + prect.Height / 2.0f);
|
|
var p2 = new PointF(srect.Left, prect.Top + prect.Height / 2.0f);
|
|
var p3 = new PointF(srect.Left, srect.Top);
|
|
var p4 = new PointF(srect.Left, srect.Top);
|
|
|
|
//var p1 = new PointF(prect.Right, prect.Top + prect.Height / 2.0f);
|
|
//var p2 = new PointF(prect.Right , prect.Top + prect.Height / 2.0f);
|
|
//var p3 = new PointF(prect.Right, srect.Top );
|
|
//var p4 = new PointF(prect.Right, srect.Top);
|
|
|
|
var size = new SizeF(Math.Abs(p4.X - p1.X), Math.Abs(p4.Y - p1.Y));
|
|
var linerect = p1.Y < p4.Y
|
|
? new RectangleF(p1, size)
|
|
: new RectangleF(new PointF(p1.X, p1.Y - size.Height), size);
|
|
if (clipRectF.IntersectsWith(linerect))
|
|
{
|
|
graphics.DrawLines(Pens.Black, new PointF[] {p1, p2, p3, p4});
|
|
graphics.FillRectangle(Brushes.Black, p4.X - 1.5f, p4.Y - 1.5f, 3, 3);
|
|
//graphics.FillRectangle(Brushes.Black, p3.X - 1.5f, p3.Y - 1.5f, 3, 3);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void __DrawRegularTaskAndGroup(Graphics graphics, TaskPaintEventArgs e, Task task, RectangleF taskRect)
|
|
{
|
|
// select task
|
|
if (_mSelectedTasks.Contains(task))
|
|
{
|
|
var solidColor = new SolidBrush(Color.FromArgb(150, 255, 255, 255));
|
|
var penColor = new Pen(Color.FromArgb(255, 0, 128, 255), 5);
|
|
|
|
if (_mProject.IsGroup(task))
|
|
{
|
|
// check if this is a parent task / group task, then draw the bracket
|
|
//if (_mProject.IsGroup(task))
|
|
var rod = new RectangleF(taskRect.Left, taskRect.Top, taskRect.Width, taskRect.Height / 2);
|
|
graphics.FillRectangle(solidColor, rod);
|
|
graphics.DrawRectangle(penColor, rod);
|
|
if (!task.IsCollapsed)
|
|
{
|
|
// left bracket
|
|
graphics.FillPolygon(Brushes.Black, new PointF[]
|
|
{
|
|
new PointF() {X = taskRect.Left, Y = taskRect.Top},
|
|
new PointF() {X = taskRect.Left, Y = taskRect.Top + BarHeight},
|
|
new PointF() {X = taskRect.Left + BarWidth, Y = taskRect.Top}
|
|
});
|
|
// right bracket
|
|
graphics.FillPolygon(Brushes.Black, new PointF[]
|
|
{
|
|
new PointF() {X = taskRect.Right, Y = taskRect.Top},
|
|
new PointF() {X = taskRect.Right, Y = taskRect.Top + BarHeight},
|
|
new PointF() {X = taskRect.Right - BarWidth, Y = taskRect.Top}
|
|
});
|
|
//graphics.DrawRectangle(penColor, rod);
|
|
|
|
var smallWidth = (float) BarWidth / 2.0f;
|
|
|
|
GraphicsPath path = new GraphicsPath();
|
|
var lines = new PointF[]
|
|
{
|
|
new PointF() {X = taskRect.Left, Y = taskRect.Top},
|
|
new PointF() {X = taskRect.Right, Y = taskRect.Top},
|
|
new PointF() {X = taskRect.Right, Y = taskRect.Bottom},
|
|
new PointF() {X = taskRect.Right - smallWidth, Y = taskRect.Top + taskRect.Height / 2.0f},
|
|
new PointF() {X = taskRect.Left + smallWidth, Y = taskRect.Top + taskRect.Height / 2.0f},
|
|
new PointF() {X = taskRect.Left, Y = taskRect.Bottom},
|
|
new PointF() {X = taskRect.Left, Y = taskRect.Top}
|
|
};
|
|
graphics.DrawLines(penColor, lines);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
graphics.FillRectangle(solidColor, taskRect);
|
|
graphics.DrawRectangle(penColor, taskRect);
|
|
}
|
|
}
|
|
|
|
//wangdequan
|
|
var fill = taskRect;
|
|
if (!_mProject.IsGroup(task))
|
|
{
|
|
fill.Width = (int) (fill.Width * task.Complete);
|
|
graphics.FillRectangle(task.BackFill, taskRect);
|
|
//graphics.FillRectangle(e.Format.BackFill, taskRect);
|
|
//graphics.FillRectangle(e.Format.ForeFill, fill);
|
|
//graphics.DrawRectangle(e.Format.Border, taskRect);
|
|
}
|
|
else
|
|
{
|
|
// check if this is a parent task / group task, then draw the bracket
|
|
//if (_mProject.IsGroup(task))
|
|
var rod = new RectangleF(taskRect.Left, taskRect.Top, taskRect.Width, taskRect.Height / 2);
|
|
var solidColor = new SolidBrush(Color.FromArgb(255, 167, 194, 228));
|
|
|
|
graphics.FillRectangle(solidColor, rod);
|
|
|
|
if (!task.IsCollapsed)
|
|
{
|
|
// left bracket
|
|
graphics.FillPolygon(solidColor, new PointF[]
|
|
{
|
|
new PointF() {X = taskRect.Left, Y = taskRect.Top},
|
|
new PointF() {X = taskRect.Left, Y = taskRect.Top + BarHeight},
|
|
new PointF() {X = taskRect.Left + BarWidth, Y = taskRect.Top}
|
|
});
|
|
// right bracket
|
|
graphics.FillPolygon(solidColor, new PointF[]
|
|
{
|
|
new PointF() {X = taskRect.Right, Y = taskRect.Top},
|
|
new PointF() {X = taskRect.Right, Y = taskRect.Top + BarHeight},
|
|
new PointF() {X = taskRect.Right - BarWidth, Y = taskRect.Top}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
private void __DrawTaskParts(Graphics graphics, TaskPaintEventArgs e, Task task, Pen pen)
|
|
{
|
|
var parts = _mChartTaskPartRects[task];
|
|
|
|
// Draw line indicator
|
|
var firstRect = parts[0].Value;
|
|
var lastRect = parts[parts.Count - 1].Value;
|
|
var y_coord = (firstRect.Top + firstRect.Bottom) / 2.0f;
|
|
var point1 = new PointF(firstRect.Right, y_coord);
|
|
var point2 = new PointF(lastRect.Left, y_coord);
|
|
graphics.DrawLine(pen, point1, point2);
|
|
|
|
// Draw Part Rectangles
|
|
var taskRects = parts.Select(x => x.Value).ToArray();
|
|
graphics.FillRectangles(e.Format.BackFill, taskRects);
|
|
|
|
// Draw % complete indicators
|
|
graphics.FillRectangles(e.Format.ForeFill,
|
|
parts.Select(x => new RectangleF(x.Value.X, x.Value.Y, x.Value.Width * x.Key.Complete, x.Value.Height))
|
|
.ToArray());
|
|
|
|
// Draw border
|
|
graphics.DrawRectangles(e.Format.Border, taskRects);
|
|
}
|
|
|
|
private RectangleF _TextAlignCenterMiddle(Graphics graphics, RectangleF rect, string text, Font font)
|
|
{
|
|
var size = graphics.MeasureString(text, font);
|
|
return new RectangleF(
|
|
new PointF(rect.Left + (rect.Width - size.Width) / 2, rect.Top + (rect.Height - size.Height) / 2),
|
|
size);
|
|
}
|
|
|
|
private RectangleF _TextAlignLeftMiddle(Graphics graphics, RectangleF rect, string text, Font font,
|
|
float leftMargin = 0.0f)
|
|
{
|
|
var size = graphics.MeasureString(text, font);
|
|
return new RectangleF(new PointF(rect.Left + leftMargin, rect.Top + (rect.Height - size.Height) / 2), size);
|
|
}
|
|
|
|
#endregion Private Helper Methods
|
|
|
|
#region Private Helper Variables
|
|
|
|
/// <summary>
|
|
/// Printing labels for header
|
|
/// </summary>
|
|
private static readonly SortedDictionary<DayOfWeek, string> ShortDays = new SortedDictionary<DayOfWeek, string>
|
|
{
|
|
{DayOfWeek.Sunday, "S"},
|
|
{DayOfWeek.Monday, "M"},
|
|
{DayOfWeek.Tuesday, "T"},
|
|
{DayOfWeek.Wednesday, "W"},
|
|
{DayOfWeek.Thursday, "T"},
|
|
{DayOfWeek.Friday, "F"},
|
|
{DayOfWeek.Saturday, "S"}
|
|
};
|
|
|
|
/// <summary>
|
|
/// Polygon points for Header markers
|
|
/// </summary>
|
|
private static readonly PointF[] _Marker = new PointF[]
|
|
{
|
|
new PointF(-4, 0),
|
|
new PointF(4, 0),
|
|
new PointF(4, 4),
|
|
new PointF(0, 8),
|
|
new PointF(-4f, 4)
|
|
};
|
|
|
|
class HeaderInfo
|
|
{
|
|
public RectangleF H1Rect;
|
|
public RectangleF H2Rect;
|
|
public List<RectangleF> H1LabelRects;
|
|
public List<RectangleF> H2LabelRects;
|
|
public List<RectangleF> Columns;
|
|
public List<DateTime> Dates;
|
|
|
|
public List<string> Dates_DT;
|
|
//public float scale;
|
|
}
|
|
|
|
|
|
public ProjectManager<Task, object>
|
|
_mProject = null; // The project to be visualised / rendered as a Gantt Chart
|
|
|
|
public IViewport _mViewport = null;
|
|
Task _mDragSource = null; // The dragged source Task
|
|
Point _mDragLastLocation = Point.Empty; // Record the dragging mouse offset
|
|
Point _mDragStartLocation = Point.Empty;
|
|
List<Task> _mSelectedTasks = new List<Task>(); // List of selected tasks
|
|
|
|
Dictionary<Task, RectangleF>
|
|
_mChartTaskHitRects = new Dictionary<Task, RectangleF>(); // list of hitareas for Task Rectangles
|
|
|
|
public Dictionary<Task, RectangleF> _mChartTaskRects = new Dictionary<Task, RectangleF>();
|
|
|
|
Dictionary<Task, List<KeyValuePair<Task, RectangleF>>> _mChartTaskPartRects =
|
|
new Dictionary<Task, List<KeyValuePair<Task, RectangleF>>>();
|
|
|
|
Dictionary<Task, RectangleF> _mChartSlackRects = new Dictionary<Task, RectangleF>();
|
|
HeaderInfo _mHeaderInfo = new HeaderInfo();
|
|
Task _mMouseEntered = null; // flag whether the mouse has entered a Task rectangle or not
|
|
Dictionary<Task, string> _mTaskToolTip = new Dictionary<Task, string>();
|
|
|
|
#endregion Private Helper Variables
|
|
}
|
|
|
|
#region Chart Formatting
|
|
|
|
/// <summary>
|
|
/// Time scale display format
|
|
/// </summary>
|
|
public enum TimeScaleDisplay
|
|
{
|
|
/// <summary>
|
|
/// Day of the week: S, M, T, W, T, F, S
|
|
/// </summary>
|
|
DayOfWeek,
|
|
|
|
/// <summary>
|
|
/// Day of month; 1 to 31
|
|
/// </summary>
|
|
DayOfMonth,
|
|
|
|
/// <summary>
|
|
/// Week of the year: 1 to 52; or 53 in case of leap year
|
|
/// </summary>
|
|
WeekOfYear
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Format for painting tasks
|
|
/// </summary>
|
|
public struct TaskFormat
|
|
{
|
|
/// <summary>
|
|
/// Get or set Task outline color
|
|
/// </summary>
|
|
public Pen Border { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set Task background color
|
|
/// </summary>
|
|
public Brush BackFill { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set Task foreground color
|
|
/// </summary>
|
|
public Brush ForeFill { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set Task font color
|
|
/// </summary>
|
|
public Brush Color { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set the brush for slack bars
|
|
/// </summary>
|
|
public Brush SlackFill { get; set; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Format for painting relations
|
|
/// </summary>
|
|
public struct RelationFormat
|
|
{
|
|
/// <summary>
|
|
/// Get or set the line pen
|
|
/// </summary>
|
|
public Pen Line { get; set; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Format for painting chart header
|
|
/// </summary>
|
|
public struct HeaderFormat
|
|
{
|
|
/// <summary>
|
|
/// Font color
|
|
/// </summary>
|
|
public Brush Color { get; set; }
|
|
|
|
/// <summary>
|
|
/// Border and line colors
|
|
/// </summary>
|
|
public Pen Border { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set the lighter color in the gradient
|
|
/// </summary>
|
|
public Color GradientLight { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set the darker color in the gradient
|
|
/// </summary>
|
|
public Color GradientDark { get; set; }
|
|
}
|
|
|
|
#endregion Chart Formatting
|
|
|
|
#region EventAgrs
|
|
|
|
/// <summary>
|
|
/// Provides data for TaskMouseEvent
|
|
/// </summary>
|
|
public class TaskMouseEventArgs : MouseEventArgs
|
|
{
|
|
/// <summary>
|
|
/// Subject Task of the event
|
|
/// </summary>
|
|
public Task Task { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Rectangle bounds of the Task
|
|
/// </summary>
|
|
public RectangleF Rectangle { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Initialize a new instance of TaskMouseEventArgs with the MouseEventArgs parameters and the Task involved.
|
|
/// </summary>
|
|
public TaskMouseEventArgs(Task task, RectangleF rectangle, MouseButtons buttons, int clicks, int x, int y,
|
|
int delta)
|
|
: base(buttons, clicks, x, y, delta)
|
|
{
|
|
this.Task = task;
|
|
this.Rectangle = rectangle;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Provides data for TaskDragDropEvent
|
|
/// </summary>
|
|
public class TaskDragDropEventArgs : MouseEventArgs
|
|
{
|
|
/// <summary>
|
|
/// Get the previous mouse location
|
|
/// </summary>
|
|
public Point PreviousLocation { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Get the starting mouse location of this drag drop event
|
|
/// </summary>
|
|
public Point StartLocation { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Get the source task that is being dragged
|
|
/// </summary>
|
|
public Task Source { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Get the target task that is being dropped on
|
|
/// </summary>
|
|
public Task Target { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Get the rectangle bounds of the source task in chart coordinates
|
|
/// </summary>
|
|
public RectangleF SourceRect { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Get the rectangle bounds of the target task in chart coordinates
|
|
/// </summary>
|
|
public RectangleF TargetRect { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Get the chart row number that the mouse is current at.
|
|
/// </summary>
|
|
public int Row { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Initialize a new instance of TaskDragDropEventArgs with the MouseEventArgs parameters and the Task involved and the previous mouse location.
|
|
/// </summary>
|
|
public TaskDragDropEventArgs(Point startLocation, Point prevLocation, Task source, RectangleF sourceRect,
|
|
Task target, RectangleF targetRect, int row, MouseButtons buttons, int clicks, int x, int y, int delta)
|
|
: base(buttons, clicks, x, y, delta)
|
|
{
|
|
this.Source = source;
|
|
this.SourceRect = sourceRect;
|
|
this.Target = target;
|
|
this.TargetRect = targetRect;
|
|
this.PreviousLocation = prevLocation;
|
|
this.StartLocation = startLocation;
|
|
this.Row = row;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Provides data for ChartPaintEvent
|
|
/// </summary>
|
|
public class ChartPaintEventArgs : PaintEventArgs
|
|
{
|
|
/// <summary>
|
|
/// Get the chart that for this event
|
|
/// </summary>
|
|
public Chart Chart { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Initialize a new instance of ChartPaintEventArgs with the PaintEventArgs graphics and clip rectangle, and the chart itself.
|
|
/// </summary>
|
|
/// <param name="graphics"></param>
|
|
/// <param name="clipRect"></param>
|
|
/// <param name="chart"></param>
|
|
public ChartPaintEventArgs(Graphics graphics, Rectangle clipRect, Chart chart)
|
|
: base(graphics, clipRect)
|
|
{
|
|
this.Chart = chart;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Provides data for ChartPaintEvent
|
|
/// </summary>
|
|
public class HeaderPaintEventArgs : ChartPaintEventArgs
|
|
{
|
|
/// <summary>
|
|
/// Get or set the font to use for drawing the text on the header
|
|
/// </summary>
|
|
public Font Font { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set the header formatting
|
|
/// </summary>
|
|
public HeaderFormat Format { get; set; }
|
|
|
|
/// <summary>
|
|
/// Initialize a new instance of HeaderPaintEventArgs with the editable default font and header format
|
|
/// </summary>
|
|
public HeaderPaintEventArgs(Graphics graphics, Rectangle clipRect, Chart chart, Font font, HeaderFormat format)
|
|
: base(graphics, clipRect, chart)
|
|
{
|
|
this.Font = font;
|
|
this.Format = format;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Provides data for TaskPaintEvent
|
|
/// </summary>
|
|
public class TaskPaintEventArgs : ChartPaintEventArgs
|
|
{
|
|
/// <summary>
|
|
/// Get the task to be painted
|
|
/// </summary>
|
|
public Task Task { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Get the rectangle bounds of the task
|
|
/// </summary>
|
|
public RectangleF Rectangle
|
|
{
|
|
get
|
|
{
|
|
return new RectangleF(this.Task.Start * this.Chart.BarWidth,
|
|
this.Row * this.Chart.BarSpacing + this.Chart.BarSpacing + this.Chart.HeaderOneHeight,
|
|
this.Task.Duration * this.Chart.BarWidth, this.Chart.BarHeight);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the row number of the task
|
|
/// </summary>
|
|
public int Row { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Get or set the font to be used to draw the task label
|
|
/// </summary>
|
|
public Font Font { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set the formatting of the task
|
|
/// </summary>
|
|
public TaskFormat Format { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get whether the task is in a critical path
|
|
/// </summary>
|
|
public bool IsCritical { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Initialize a new instance of TaskPaintEventArgs with the editable default font and task paint format
|
|
/// </summary>
|
|
public TaskPaintEventArgs(Graphics graphics, Rectangle clipRect, Chart chart, Task task, int row, bool critical,
|
|
Font font, TaskFormat format) // need to create a paint event for each task for custom painting
|
|
: base(graphics, clipRect, chart)
|
|
{
|
|
this.Task = task;
|
|
this.Row = row;
|
|
this.Font = font;
|
|
this.Format = format;
|
|
this.IsCritical = critical;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Provides data for RelationPaintEvent
|
|
/// </summary>
|
|
public class RelationPaintEventArgs : ChartPaintEventArgs
|
|
{
|
|
/// <summary>
|
|
/// Get the precedent task in the relation
|
|
/// </summary>
|
|
public Task Precedent { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Get the dependant task in the relation
|
|
/// </summary>
|
|
public Task Dependant { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Get or set the formatting to use for drawing the relation
|
|
/// </summary>
|
|
public RelationFormat Format { get; set; }
|
|
|
|
/// <summary>
|
|
/// Initialize a new instance of RelationPaintEventArgs with the editable default font and relation paint format
|
|
/// </summary>
|
|
public RelationPaintEventArgs(Graphics graphics, Rectangle clipRect, Chart chart, Task before, Task after,
|
|
RelationFormat format)
|
|
: base(graphics, clipRect, chart)
|
|
{
|
|
this.Precedent = before;
|
|
this.Dependant = after;
|
|
this.Format = format;
|
|
}
|
|
}
|
|
|
|
#endregion EventArgs
|
|
|
|
/// <summary>
|
|
/// Provides information about the chart at a specific row and date/time.
|
|
/// </summary>
|
|
public struct ChartInfo
|
|
{
|
|
/// <summary>
|
|
/// Get or set the chart row number
|
|
/// </summary>
|
|
public int Row { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set the chart date/time
|
|
/// </summary>
|
|
public DateTime DateTime { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get or set the task
|
|
/// </summary>
|
|
public Task Task { get; set; }
|
|
|
|
/// <summary>
|
|
/// Construct a passive data structure to hold chart information
|
|
/// </summary>
|
|
/// <param name="row"></param>
|
|
/// <param name="dateTime"></param>
|
|
/// <param name="task"></param>
|
|
public ChartInfo(int row, DateTime dateTime, Task task)
|
|
: this()
|
|
{
|
|
Row = row;
|
|
DateTime = dateTime;
|
|
Task = task;
|
|
}
|
|
}
|
|
|
|
public class Row
|
|
{
|
|
public int Index { get; set; }
|
|
public float Height { get; set; }
|
|
}
|
|
|
|
public class Column
|
|
{
|
|
public int Index { get; set; }
|
|
public DateTime DateTime { get; set; }
|
|
}
|
|
} |