510 lines
18 KiB
C#
510 lines
18 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Xml;
|
|
using System.Drawing;
|
|
using System.Drawing.Imaging;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Collections.Generic;
|
|
using Payroll.BO.Organogram;
|
|
|
|
namespace Payroll.BO
|
|
{
|
|
class OrganisationChart : IDisposable
|
|
{
|
|
private Graphics _gr;
|
|
private int _imgWidth = 0;
|
|
private int _imgHeight = 0;
|
|
|
|
public OrganisationChart(OrgData.OrgDetailsDataTable OrganizationalDataTable)
|
|
{
|
|
_dtOrg = OrganizationalDataTable;
|
|
}
|
|
|
|
#region Properties
|
|
|
|
/// <summary>
|
|
/// the employee data
|
|
/// </summary>
|
|
private OrgData.OrgDetailsDataTable _dtOrg;
|
|
|
|
/// <summary>
|
|
/// A list of the employee positions.
|
|
/// </summary>
|
|
//private List<EmployeePos> EmpPositions;
|
|
// A Dictionary of all employee data
|
|
private SortedDictionary<string, ChartRecord> _employeeChartData;
|
|
public SortedDictionary<string, ChartRecord> EmployeeData
|
|
{
|
|
get { return _employeeChartData; }
|
|
set { _employeeChartData = value; }
|
|
}
|
|
|
|
private Color _boxFillColor = Color.AliceBlue;
|
|
public Color BoxFillColor
|
|
{
|
|
get { return _boxFillColor; }
|
|
set { _boxFillColor = value; }
|
|
}
|
|
|
|
private int _boxWidth = 130;
|
|
public int BoxWidth
|
|
{
|
|
get { return _boxWidth; }
|
|
set { _boxWidth = value; }
|
|
}
|
|
|
|
private int _boxHeight = 40;
|
|
public int BoxHeight
|
|
{
|
|
get { return _boxHeight; }
|
|
set { _boxHeight = value; }
|
|
}
|
|
|
|
private int _margin = 20;
|
|
public int Margin
|
|
{
|
|
get { return _margin; }
|
|
set { _margin = value; }
|
|
}
|
|
|
|
private int _horizontalSpace = 5;
|
|
public int HorizontalSpace
|
|
{
|
|
get { return _horizontalSpace; }
|
|
set { _horizontalSpace = value; }
|
|
}
|
|
|
|
private int _verticalSpace = 20;
|
|
public int VerticalSpace
|
|
{
|
|
get { return _verticalSpace; }
|
|
set { _verticalSpace = value; }
|
|
}
|
|
|
|
private int _fontSize = 6;
|
|
public int FontSize
|
|
{
|
|
get { return _fontSize; }
|
|
set { _fontSize = value; }
|
|
}
|
|
|
|
private Color _lineColor = Color.Black;
|
|
public Color LineColor
|
|
{
|
|
get { return _lineColor; }
|
|
set { _lineColor = value; }
|
|
}
|
|
|
|
private float _lineWidth = 2;
|
|
public float LineWidth
|
|
{
|
|
get { return _lineWidth; }
|
|
set { _lineWidth = value; }
|
|
}
|
|
|
|
private Color _bgColor = Color.White;
|
|
public Color BGColor
|
|
{
|
|
get { return _bgColor; }
|
|
set { _bgColor = value; }
|
|
}
|
|
|
|
private Color _fontColor = Color.Black;
|
|
public Color FontColor
|
|
{
|
|
get { return _fontColor; }
|
|
set { _fontColor = value; }
|
|
}
|
|
|
|
private string _selID = string.Empty;
|
|
public string SelectedEmployeeID
|
|
{
|
|
set { _selID = value; }
|
|
}
|
|
|
|
private Color _selFontColor = Color.Black;
|
|
public Color SelectedFontColor
|
|
{
|
|
get { return _selFontColor; }
|
|
set { _selFontColor = value; }
|
|
}
|
|
|
|
private Color _selBackColor = Color.LightBlue;
|
|
public Color SelectedBakcColor
|
|
{
|
|
get { return _selBackColor; }
|
|
set { _selBackColor = value; }
|
|
}
|
|
|
|
private string _selFont = "verdana";
|
|
public string SelectedFont
|
|
{
|
|
get { return _selFont; }
|
|
set { _selFont = value; }
|
|
}
|
|
|
|
private int _selFontSize = 7;
|
|
public int SelectedFontSize
|
|
{
|
|
get { return _selFontSize; }
|
|
set { _selFontSize = value; }
|
|
}
|
|
|
|
private StringAlignment _horizontalAlignment = StringAlignment.Center;
|
|
public StringAlignment HorizontalAlignment
|
|
{
|
|
get { return _horizontalAlignment; }
|
|
set { _horizontalAlignment = value; }
|
|
}
|
|
|
|
private StringAlignment _verticalAlignment = StringAlignment.Near;
|
|
public StringAlignment VerticalAlignment
|
|
{
|
|
get { return _verticalAlignment; }
|
|
set { _verticalAlignment = value; }
|
|
}
|
|
#endregion Properties
|
|
|
|
public ChartRecord GetRecord(int scale, Point p)
|
|
{
|
|
foreach (ChartRecord cr in this.EmployeeData.Values)
|
|
{
|
|
Rectangle r = cr.CurrentLocation(scale);
|
|
if (p.X >= r.Left && p.X <= r.Right && p.Y >= r.Top && p.Y <= r.Bottom)
|
|
return cr;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_dtOrg = null;
|
|
|
|
if (_gr != null)
|
|
{
|
|
_gr.Dispose();
|
|
_gr = null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The main function used to create the image
|
|
/// </summary>
|
|
/// <param name="Width"></param>
|
|
/// <param name="Height"></param>
|
|
/// <param name="BossEmployeeID">The ID of the Boss from which to start building the chart</param>
|
|
/// <param name="ImageType"></param>
|
|
/// <returns>A stream of the image. can be shown or saved to disk.</returns>
|
|
public Stream GenerateOrgChart(int defaultWidth, int defaultHeight, int width, int height, string bossEmployeeID, ImageFormat imageType)
|
|
{
|
|
MemoryStream Result = new MemoryStream();
|
|
|
|
_employeeChartData = new SortedDictionary<string, ChartRecord>();
|
|
|
|
//reset image size
|
|
_imgHeight = 0;
|
|
_imgWidth = 0;
|
|
_orgTree = null;
|
|
_orgTree = new XmlDocument();
|
|
|
|
XmlNode RootNode = _orgTree.CreateNode(XmlNodeType.Element, "RootNode", "");
|
|
|
|
XmlAttribute Att = _orgTree.CreateAttribute("EmployeeID");
|
|
Att.InnerText = bossEmployeeID;
|
|
RootNode.Attributes.Append(Att);
|
|
_orgTree.AppendChild(RootNode);
|
|
BuildTree(RootNode, 0);
|
|
|
|
Bitmap bmp = new Bitmap(_imgWidth, _imgHeight);
|
|
_gr = Graphics.FromImage(bmp);
|
|
_gr.Clear(_bgColor);
|
|
DrawChart(RootNode);
|
|
|
|
//if caller does not care about size, use original calculated size
|
|
if (width < 0)
|
|
{
|
|
width = _imgWidth;
|
|
}
|
|
if (height < 0)
|
|
{
|
|
height = _imgHeight;
|
|
}
|
|
|
|
double gR = 0;
|
|
double wR = (double)defaultWidth / (double)width;
|
|
double hR = (double)defaultHeight / (double)height;
|
|
|
|
if (wR > hR)
|
|
gR = wR;
|
|
else
|
|
gR = hR;
|
|
|
|
if (gR > 1)
|
|
{
|
|
width = Convert.ToInt32((double)width * gR);
|
|
height = Convert.ToInt32((double)height * gR);
|
|
}
|
|
|
|
Bitmap ResizedBMP = new Bitmap(bmp, new Size(width, height));
|
|
//after resize - change the coordinates of the list, in order return the proper coordinates for each employee
|
|
CalculateImageMapData(width, height);
|
|
ResizedBMP.Save(Result, imageType);
|
|
|
|
ResizedBMP.Dispose();
|
|
bmp.Dispose();
|
|
_gr.Dispose();
|
|
return Result;
|
|
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// This overloaded method can be used to return the image using it's default calculated size, without resizing
|
|
/// </summary>
|
|
/// <param name="BossEmployeeID"></param>
|
|
/// <param name="ImageType"></param>
|
|
/// <returns></returns>
|
|
public Stream GenerateOrgChart(int defaultWidth, int defaultHeight, string bossEmployeeID, ImageFormat imageType)
|
|
{
|
|
return GenerateOrgChart(defaultWidth, defaultHeight, -1, -1, bossEmployeeID, imageType);
|
|
|
|
|
|
}
|
|
|
|
private XmlDocument _orgTree;
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="employeeNode"></param>
|
|
/// <param name="y"></param>
|
|
private void BuildTree(XmlNode employeeNode, int y)
|
|
{
|
|
//has employees
|
|
System.Data.DataRow[] oRows = _dtOrg.Select(string.Format("BossEmployeeID='{0}'", employeeNode.Attributes["EmployeeID"].InnerText));
|
|
if (oRows == null) return;
|
|
foreach (OrgData.OrgDetailsRow EmployeeRow in oRows)
|
|
{
|
|
//for each employee call this function again
|
|
XmlNode NewEmployeeNode = _orgTree.CreateElement("Node");
|
|
|
|
XmlAttribute Att = _orgTree.CreateAttribute("EmployeeID");
|
|
Att.InnerText = EmployeeRow.EmployeeID;
|
|
NewEmployeeNode.Attributes.Append(Att);
|
|
employeeNode.AppendChild(NewEmployeeNode);
|
|
BuildTree(NewEmployeeNode, y + 1);
|
|
|
|
}
|
|
//build employee data after checking for employees we can add the current employee
|
|
ChartRecord currentEmp = new ChartRecord();
|
|
currentEmp.EmployeeData = ((OrgData.OrgDetailsRow)_dtOrg.Select(string.Format("EmployeeID='{0}'", employeeNode.Attributes["EmployeeID"].Value))[0]);
|
|
currentEmp.EmployeeCount = employeeNode.ChildNodes.Count;
|
|
|
|
int[] resultsArr = new int[] {GetXPosByOwnChildren(employeeNode),
|
|
GetXPosByParentPreviousSibling(employeeNode),
|
|
GetXPosByPreviousSibling(employeeNode),
|
|
_margin };
|
|
Array.Sort(resultsArr);
|
|
|
|
int startX = resultsArr[3];
|
|
int startY = (y * (_boxHeight + _verticalSpace)) + _margin;
|
|
int width = _boxWidth;
|
|
int height = _boxHeight;
|
|
//update the coordinates of this box into the matrix, for later calculations
|
|
|
|
Rectangle drawRect = new Rectangle(startX, startY, width, height);
|
|
//update the image size
|
|
if (_imgWidth < (startX + width + _margin))
|
|
{
|
|
_imgWidth = startX + width + _margin;
|
|
}
|
|
if (_imgHeight < (startY + height + _margin))
|
|
{
|
|
_imgHeight = startY + height + _margin;
|
|
}
|
|
currentEmp.EmployeePos = drawRect;
|
|
|
|
_employeeChartData.Add(currentEmp.EmployeeData.EmployeeID, currentEmp);
|
|
|
|
currentEmp.Dispose();
|
|
currentEmp = null;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="currentNode"></param>
|
|
/// <returns></returns>
|
|
private int GetXPosByPreviousSibling(XmlNode currentNode)
|
|
{
|
|
int result = -1;
|
|
XmlNode prevSibling = currentNode.PreviousSibling;
|
|
|
|
if (prevSibling != null)
|
|
{
|
|
if (prevSibling.HasChildNodes)
|
|
{
|
|
result = _employeeChartData[prevSibling.LastChild.Attributes["EmployeeID"].Value].EmployeePos.X + _boxWidth + _horizontalSpace;
|
|
}
|
|
else
|
|
{
|
|
result = _employeeChartData[prevSibling.Attributes["EmployeeID"].Value].EmployeePos.X + _boxWidth + _horizontalSpace;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="currentNode"></param>
|
|
/// <returns></returns>
|
|
private int GetXPosByOwnChildren(XmlNode currentNode)
|
|
{
|
|
int result = -1;
|
|
|
|
if (currentNode.HasChildNodes)
|
|
{
|
|
result = (((_employeeChartData[currentNode.LastChild.Attributes["EmployeeID"].Value].EmployeePos.X + _boxWidth) -
|
|
_employeeChartData[currentNode.FirstChild.Attributes["EmployeeID"].Value].EmployeePos.X) / 2) -
|
|
(_boxWidth / 2) +
|
|
_employeeChartData[currentNode.FirstChild.Attributes["EmployeeID"].Value].EmployeePos.X;
|
|
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="currentNode"></param>
|
|
/// <returns></returns>
|
|
private int GetXPosByParentPreviousSibling(XmlNode currentNode)
|
|
{
|
|
int result = -1;
|
|
XmlNode parentPrevSibling = currentNode.ParentNode.PreviousSibling;
|
|
|
|
if (parentPrevSibling != null)
|
|
{
|
|
if (parentPrevSibling.HasChildNodes)
|
|
{
|
|
result = _employeeChartData[parentPrevSibling.LastChild.Attributes["EmployeeID"].Value].EmployeePos.X + _boxWidth + _horizontalSpace;
|
|
}
|
|
else
|
|
{
|
|
result = _employeeChartData[parentPrevSibling.Attributes["EmployeeID"].Value].EmployeePos.X + _boxWidth + _horizontalSpace;
|
|
}
|
|
}
|
|
else //ParentPrevSibling == null
|
|
{
|
|
if (currentNode.ParentNode.Name != "RootNode" && currentNode.ParentNode.Name != "#document")
|
|
{
|
|
result = GetXPosByParentPreviousSibling(currentNode.ParentNode);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Draws the actual chart image.
|
|
/// </summary>
|
|
private void DrawChart(XmlNode node)
|
|
{
|
|
// Create font and brush.
|
|
Font drawFont = new Font("verdana", _fontSize);
|
|
SolidBrush drawBrush = new SolidBrush(_fontColor);
|
|
Pen boxPen = new Pen(_lineColor, _lineWidth);
|
|
StringFormat drawFormat = new StringFormat();
|
|
|
|
drawFormat.Alignment = this.VerticalAlignment;//StringAlignment.Near;
|
|
|
|
drawFormat.LineAlignment = this.HorizontalAlignment;//StringAlignment.Center;
|
|
|
|
foreach (OrgData.OrgDetailsRow EmployeeRow in _dtOrg.Select(string.Format("BossEmployeeID='{0}'", node.Attributes["EmployeeID"].Value)))
|
|
{
|
|
DrawChart(node.SelectSingleNode(string.Format("Node[@EmployeeID='{0}']", EmployeeRow.EmployeeID)));
|
|
}
|
|
|
|
|
|
string empID = node.Attributes["EmployeeID"].Value;
|
|
|
|
//// Create string to draw.
|
|
//string drawString = _employeeChartData[empID].EmployeeData.EmployeeID +
|
|
// Environment.NewLine +
|
|
// _employeeChartData[empID].EmployeeData.EmployeeTitle;
|
|
|
|
string drawString = _employeeChartData[empID].EmployeeData.EmployeeTitle;
|
|
if (!string.IsNullOrEmpty(_selID) && _selID == empID)
|
|
{
|
|
drawFont = new Font(_selFont, _selFontSize);
|
|
drawBrush = new SolidBrush(_selFontColor);
|
|
_gr.DrawRectangle(boxPen, _employeeChartData[empID].EmployeePos);
|
|
_gr.FillRectangle(new SolidBrush(_selBackColor), _employeeChartData[empID].EmployeePos);
|
|
_gr.DrawString(drawString, drawFont, drawBrush, _employeeChartData[empID].EmployeePos, drawFormat);
|
|
}
|
|
else
|
|
{
|
|
drawFormat.Alignment = StringAlignment.Center;
|
|
drawFormat.LineAlignment = StringAlignment.Near;
|
|
_gr.DrawRectangle(boxPen, _employeeChartData[empID].EmployeePos);
|
|
_gr.FillRectangle(new SolidBrush(_boxFillColor), _employeeChartData[empID].EmployeePos);
|
|
_gr.DrawString(drawString, drawFont, drawBrush, _employeeChartData[empID].EmployeePos, drawFormat);
|
|
}
|
|
|
|
//draw connecting lines
|
|
if (node.Name != "RootNode")
|
|
{
|
|
//all but the top box should have lines growing out of their top
|
|
_gr.DrawLine(boxPen, _employeeChartData[empID].EmployeePos.Left + (_boxWidth / 2),
|
|
_employeeChartData[empID].EmployeePos.Top,
|
|
_employeeChartData[empID].EmployeePos.Left + (_boxWidth / 2),
|
|
_employeeChartData[empID].EmployeePos.Top - (_verticalSpace / 2));
|
|
}
|
|
|
|
if (node.HasChildNodes)
|
|
{
|
|
//all employees which have employees should have lines coming from bottom down
|
|
_gr.DrawLine(boxPen, _employeeChartData[empID].EmployeePos.Left + (_boxWidth / 2),
|
|
_employeeChartData[empID].EmployeePos.Top + _boxHeight,
|
|
_employeeChartData[empID].EmployeePos.Left + (_boxWidth / 2),
|
|
_employeeChartData[empID].EmployeePos.Top + _boxHeight + (_verticalSpace / 2));
|
|
|
|
}
|
|
|
|
if (node.PreviousSibling != null)
|
|
{
|
|
//the prev employee has the same boss - connect the 2 employees
|
|
_gr.DrawLine(boxPen, _employeeChartData[node.PreviousSibling.Attributes["EmployeeID"].Value].EmployeePos.Left + (_boxWidth / 2) - (_lineWidth / 2),
|
|
_employeeChartData[node.PreviousSibling.Attributes["EmployeeID"].Value].EmployeePos.Top - (_verticalSpace / 2),
|
|
_employeeChartData[node.Attributes["EmployeeID"].Value].EmployeePos.Left + (_boxWidth / 2) + (_lineWidth / 2),
|
|
_employeeChartData[node.Attributes["EmployeeID"].Value].EmployeePos.Top - (_verticalSpace / 2));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="actualWidth"></param>
|
|
/// <param name="actualHeight"></param>
|
|
private void CalculateImageMapData(double actualWidth, double actualHeight)
|
|
{
|
|
double percentageChangeX = actualWidth / _imgWidth;
|
|
double PercentageChangeY = actualHeight / _imgHeight;
|
|
|
|
foreach (ChartRecord cr in _employeeChartData.Values)
|
|
{
|
|
|
|
Rectangle resizedRectangle = new Rectangle(
|
|
(int)(cr.EmployeePos.X * percentageChangeX),
|
|
(int)(cr.EmployeePos.Y * PercentageChangeY),
|
|
(int)(BoxWidth * percentageChangeX),
|
|
(int)(BoxHeight * PercentageChangeY));
|
|
|
|
cr.EmployeePos = resizedRectangle;
|
|
}
|
|
}
|
|
}
|
|
}
|