public override void ViewDidLoad()
{
base.ViewDidLoad();
// Perform any additional setup after loading the view, typically from a nib.
var today = DateTime.UtcNow.Date;
var items = new[]
{
new GanttChartItem(label: "Task 1", row: 0, start: (NSDate)today, finish: (NSDate)today.AddDays(1)),
new GanttChartItem(label: "Task 2", row: 1, start: (NSDate)today, finish: (NSDate)today.AddDays(2)),
new GanttChartItem(label: "Task 3", row: 2, start: (NSDate)today.AddDays(3), finish: (NSDate)today.AddDays(7))
};
var dependencies = new[]
{
new GanttChartDependency(from: items[1], to: items[2])
};
var ganttChart = new GanttChart(items, dependencies, itemObserver: this);
ganttChart.TranslatesAutoresizingMaskIntoConstraints = false;
View.AddSubview(ganttChart);
NSLayoutConstraint.ActivateConstraints(new[]
{
ganttChart.LeadingAnchor.ConstraintEqualTo(View.LeadingAnchor),
ganttChart.TrailingAnchor.ConstraintEqualTo(View.TrailingAnchor),
ganttChart.TopAnchor.ConstraintEqualTo(View.TopAnchor),
ganttChart.BottomAnchor.ConstraintEqualTo(View.BottomAnchor)
});
}
private void Gantt_Loaded(object sender, RoutedEventArgs e)
{
Border border = VisualTreeHelper.GetChild(Gantt, 0) as Border;
Grid grid = VisualTreeHelper.GetChild(border, 0) as Grid;
ScrollViewer scrollViewer = VisualTreeHelper.GetChild(grid, 2) as ScrollViewer;
Grid scrollGrid = scrollViewer.Content as Grid;
ganttChart = VisualTreeHelper.GetChild(scrollGrid, 1) as GanttChart;
ganttSchedule = VisualTreeHelper.GetChild(scrollGrid, 0) as GanttSchedule;
List <StripLineInfo> stripCollection = new List <StripLineInfo>();
var differenceTime = (this.ganttSchedule.EndTime - this.ganttSchedule.StartTime).Days;
for (int i = 0; i < differenceTime; i++)
{
stripCollection.Add(new StripLineInfo()
{
Type = StriplineType.Absolute,
Width = 2,
Height = this.ganttChart.ActualHeight,
Position = new Point(PositionCalculation(this.ganttSchedule.StartTime.AddDays(i)), 0),
HorizontalContentAlignment = HorizontalAlignment.Center,
VerticalContentAlignment = VerticalAlignment.Center,
Background = new SolidColorBrush(Colors.Orange),
});
}
model.StripCollection = stripCollection;
}
private void loadGanttChart()
{
// If the Gantt control is already loaded, dispose of it.
if (this.Contains(ganttTimeline))
{
ganttTimeline.Dispose();
}
ganttTimeline = new GanttChart();
ganttTimeline.AllowChange = false;
ganttTimeline.Dock = DockStyle.Fill;
panel1.Controls.Add(ganttTimeline);
ganttTimeline.MouseMove += new MouseEventHandler(ganttTimeline.GanttChart_MouseMove);
ganttTimeline.MouseMove += new MouseEventHandler(GanttTimeline_MouseMove);
ganttTimeline.MouseDragged += new MouseEventHandler(ganttTimeline.GanttChart_MouseDragged);
ganttTimeline.MouseLeave += new EventHandler(ganttTimeline.GanttChart_MouseLeave);
ganttTimeline.ContextMenuStrip = ContextMenuGanttTimeline;
DateTime dateToDisplay = this.dateTimePicker1.Value;
ganttTimeline.FromDate = new DateTime(dateToDisplay.Year, dateToDisplay.Month, dateToDisplay.Day, 0, 0, 0);
ganttTimeline.ToDate = new DateTime(dateToDisplay.Year, dateToDisplay.Month, dateToDisplay.Day, 23, 59, 59);
List <BarInformation> lst1 = new List <BarInformation>();
DataTable dt = getJobHistory();
int index = 0;
string prevJobName = "";
foreach (DataRow row in dt.Rows)
{
JobFilter jobCategory = categoriesToDisplay.Find(x => x.CategoryName == row[4].ToString());
if (jobCategory.IsChecked == true)
{
Color mainColor = new Color();
if (row[1].ToString() == "1")
{
mainColor = Color.Green;
}
else
{
mainColor = Color.Red;
}
if (row[0].ToString() != prevJobName)
{
index += 1;
}
prevJobName = row[0].ToString();
lst1.Add(new BarInformation(row[0].ToString(), DateTime.Parse(row[2].ToString()), DateTime.Parse(row[3].ToString()), mainColor, Color.Khaki, index));
}
}
foreach (BarInformation bar in lst1)
{
ganttTimeline.AddChartBar
(bar.RowText, bar, bar.FromTime, bar.ToTime, bar.Color, bar.HoverColor, bar.Index);
}
}
public void TestDecimalValuesAreRounded()
{
var chart = new GanttChart
{
MaximumChartWidth = 60,
Activities = new[]
{
new GanttChartActivity {
Name = "Fetch HTML", StartValue = 0, EndValue = 1.2
},
new GanttChartActivity {
Name = "Fetch Images", StartValue = 0, EndValue = 1.8
},
new GanttChartActivity {
Name = "Render Page", StartValue = 1.2, EndValue = 3.6
},
}
};
chart.AssertOutputEquals(
" Fetch HTML |= 0 -> 1.2 (1.2)" + Environment.NewLine +
" Fetch Images |== 0 -> 1.8 (1.8)" + Environment.NewLine +
" Render Page | == 1.2 -> 3.6 (2.4)" + Environment.NewLine +
" ----" + Environment.NewLine,
"<pre><code>Fetch HTML |= 0 -> 1.2 (1.2)\n" +
"Fetch Images |== 0 -> 1.8 (1.8)\n" +
"Render Page | == 1.2 -> 3.6 (2.4)\n" +
" ----\n" +
"</code></pre>\n\n"
);
}
/// <summary>
/// Initialize a new instance of RelationPaintEventArgs with the editable default font and relation paint format
/// </summary>
public RelationPaintEventArgs(Graphics graphics, Rectangle clipRect, GanttChart chart, Task before, Task after, RelationFormat format)
: base(graphics, clipRect, chart)
{
this.Precedent = before;
this.Dependant = after;
this.Format = format;
}
public TimelinePaintEventArgs(Graphics graphics, Rectangle clipRect, GanttChart chart, DateTime datetime, DateTime datetimeprev, LabelFormat minor, LabelFormat major)
: base(graphics, clipRect, chart)
{
Handled = false;
DateTime = datetime;
DateTimePrev = datetimeprev;
Minor = minor;
Major = major;
}
void Awake()
{
chart = gameObject.GetComponent <GanttChart>();
if (chart == null)
{
chart = gameObject.AddComponent <GanttChart>();
}
GenerateCategoryData();
}
/// <summary>
/// Initialize a new instance of TaskPaintEventArgs with the editable default font and task paint format
/// </summary>
public TaskPaintEventArgs(Graphics graphics, Rectangle clipRect, GanttChart chart, GanttChartTask 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)
{
Task = task;
Row = row;
Font = font;
Format = format;
IsCritical = critical;
}
public static void SetupCategories(GanttChart ganttChart)
{
ganttChart.AddCategory(TaskState.Offline.ToString(), Color.Gainsboro);
ganttChart.AddCategory(TaskState.Waiting.ToString(), Color.NavajoWhite);
ganttChart.AddCategory(TaskState.Paused.ToString(), Color.PaleVioletRed);
ganttChart.AddCategory(TaskState.Transferring.ToString(), Color.CornflowerBlue);
ganttChart.AddCategory(TaskState.Calculating.ToString(), Color.DarkGreen);
ganttChart.AddCategory(TaskState.Finished.ToString(), Color.White);
ganttChart.AddCategory(TaskState.Aborted.ToString(), Color.Orange);
ganttChart.AddCategory(TaskState.Failed.ToString(), Color.Red);
}
public void TestZeroLengthActivitiesArePlotted()
{
var chart = new GanttChart
{
MaximumChartWidth = 60,
Activities = new[]
{
new GanttChartActivity {
Name = "v1.0 Release Date", StartValue = -10, EndValue = -10
},
new GanttChartActivity {
Name = "Today", StartValue = 0, EndValue = 0
},
new GanttChartActivity {
Name = "Feasibility Study", StartValue = 0, EndValue = 5
},
new GanttChartActivity {
Name = "Requirements Gathering", StartValue = 4, EndValue = 10
},
new GanttChartActivity {
Name = "Development", StartValue = 8, EndValue = 15
},
new GanttChartActivity {
Name = "Testing", StartValue = 11, EndValue = 18
},
new GanttChartActivity {
Name = "v2.0 Release Date", StartValue = 20, EndValue = 20
},
}
};
chart.AssertOutputEquals(
" v1.0 Release Date + | -10 -> -10 (0)" + Environment.NewLine +
" Today + 0 -> 0 (0)" + Environment.NewLine +
" Feasibility Study |===== 0 -> 5 (5)" + Environment.NewLine +
" Requirements Gathering | ====== 4 -> 10 (6)" + Environment.NewLine +
" Development | ======= 8 -> 15 (7)" + Environment.NewLine +
" Testing | ======= 11 -> 18 (7)" + Environment.NewLine +
" v2.0 Release Date | + 20 -> 20 (0)" + Environment.NewLine +
" -------------------------------" + Environment.NewLine,
"<pre><code>v1.0 Release Date + | -10 -> -10 (0)\n" +
"Today + 0 -> 0 (0)\n" +
"Feasibility Study |===== 0 -> 5 (5)\n" +
"Requirements Gathering | ====== 4 -> 10 (6)\n" +
"Development | ======= 8 -> 15 (7)\n" +
"Testing | ======= 11 -> 18 (7)\n" +
"v2.0 Release Date | + 20 -> 20 (0)\n" +
" -------------------------------\n" +
"</code></pre>\n\n"
);
}
public void TestCanPlotGanttChart()
{
var chart = new GanttChart
{
Activities = new[]
{
new GanttChartActivity {
Name = "Boil Kettle", StartValue = 0, EndValue = 5
},
new GanttChartActivity {
Name = "Find Mugs", StartValue = 1, EndValue = 3
},
new GanttChartActivity {
Name = "Add Tea Bag", StartValue = 3, EndValue = 4
},
new GanttChartActivity {
Name = "Pour Water in Mug", StartValue = 5, EndValue = 6
},
new GanttChartActivity {
Name = "Add Milk", StartValue = 8, EndValue = 9
},
new GanttChartActivity {
Name = "Remove Tea Bag", StartValue = 9, EndValue = 10
},
new GanttChartActivity {
Name = "Drink Tea", StartValue = 15, EndValue = 25
},
}
};
chart.AssertOutputEquals(
" Boil Kettle |===== 0 -> 5 (5)" + Environment.NewLine +
" Find Mugs | == 1 -> 3 (2)" + Environment.NewLine +
" Add Tea Bag | = 3 -> 4 (1)" + Environment.NewLine +
" Pour Water in Mug | = 5 -> 6 (1)" + Environment.NewLine +
" Add Milk | = 8 -> 9 (1)" + Environment.NewLine +
" Remove Tea Bag | = 9 -> 10 (1)" + Environment.NewLine +
" Drink Tea | ========== 15 -> 25 (10)" + Environment.NewLine +
" --------------------------" + Environment.NewLine
,
"<pre><code>Boil Kettle |===== 0 -> 5 (5)\n" +
"Find Mugs | == 1 -> 3 (2)\n" +
"Add Tea Bag | = 3 -> 4 (1)\n" +
"Pour Water in Mug | = 5 -> 6 (1)\n" +
"Add Milk | = 8 -> 9 (1)\n" +
"Remove Tea Bag | = 9 -> 10 (1)\n" +
"Drink Tea | ========== 15 -> 25 (10)\n" +
" --------------------------\n" +
"</code></pre>\n\n");
}
public static void AddData(GanttChart ganttChart, string name, StateLog from, StateLog to, DateTime upperLimit)
{
DateTime until = to != null ? to.DateTime : upperLimit;
TimeSpan duration = until - from.DateTime;
string tooltip = string.Format("Task: {0} " + Environment.NewLine + "Task Id: {1}" + Environment.NewLine + "State: {2} " + Environment.NewLine + "Duration: {3} " + Environment.NewLine + "{4} - {5}" + Environment.NewLine, from.TaskName, from.TaskId, from.State, duration, from.DateTime, until);
if (to != null && to.SlaveId != null)
{
tooltip += "Slave: " + to.SlaveId;
}
if (!string.IsNullOrEmpty(from.Exception))
{
tooltip += Environment.NewLine + from.Exception;
}
ganttChart.AddData(name, from.State.ToString(), from.DateTime, until, tooltip, false);
}
public void TestCanPlotGanttChartWithBackwardsActivities()
{
var chart = new GanttChart
{
Activities = new[]
{
new GanttChartActivity {
Name = "Backwards Activity", StartValue = 9, EndValue = 3
}
}
};
chart.AssertOutputEquals(
" Backwards Activity | ====== 9 -> 3 (6)" + Environment.NewLine +
" ----------" + Environment.NewLine,
"<pre><code>Backwards Activity | ====== 9 -> 3 (6)" + Environment.NewLine +
" ----------" + Environment.NewLine +
"</code></pre>" + Environment.NewLine + Environment.NewLine);
}
public void TestCanPlotGanttChartWithBackwardsActivities()
{
var chart = new GanttChart
{
Activities = new[]
{
new GanttChartActivity {
Name = "Backwards Activity", StartValue = 9, EndValue = 3
}
}
};
chart.AssertOutputEquals(
" Backwards Activity | ====== 9 -> 3 (6)\r\n" +
" ----------\r\n",
"<pre><code>Backwards Activity | ====== 9 -> 3 (6)\n" +
" ----------\n" +
"</code></pre>\n\n");
}
private void ComputeWithData(int numberOfEmployees, int numberOfJobs, List <Tuple <char, char> > dependecies)
{
/// ----- CREATING A CHART IN MODEL ------
///
var dict = DependenceTreeCreator.ConvertListToDict(dependecies);
GanttChart chart = null;
try
{
var tree = DependenceTreeCreator.CreateFromDependenceDictionary(dict, numberOfJobs);
tree.SetPriorities();
chart = new GanttChart(numberOfEmployees);
chart.Fill(tree);
}
catch (InvalidDependenciesCountException e)
{
MessageBox.Show("Error: " + e.Message);
return;
}
catch (InvalidJobCountException e)
{
MessageBox.Show("Error: " + e.Message);
return;
}
catch (InvalidWorkersCountException e)
{
MessageBox.Show("Error: " + e.Message);
return;
}
catch (Exception)
{
MessageBox.Show("Something bad happened. Try again!");
return;
}
GanttChartView ganttChartView = new GanttChartView();
ganttChartView.Show();
ganttChartView.ShowDataOnChart(chart.Chart);
}
/// <summary>
/// Initialize a new instance of HeaderPaintEventArgs with the editable default font and header format
/// </summary>
public HeaderPaintEventArgs(Graphics graphics, Rectangle clipRect, GanttChart chart, Font font, HeaderFormat format)
: base(graphics, clipRect, chart)
{
this.Font = font;
this.Format = format;
}
public void TestCanPlotEmptyGanttChart()
{
var chart = new GanttChart();
chart.AssertOutputEquals("", "");
}
public void TestCanPlotScaledGanttChart()
{
var chart = new GanttChart
{
MaximumChartWidth = 60,
Activities = new[]
{
new GanttChartActivity {
Name = "Site Preparation", StartValue = 1, EndValue = 10
},
new GanttChartActivity {
Name = "Dig Trenches", StartValue = 12, EndValue = 16
},
new GanttChartActivity {
Name = "Drains", StartValue = 16, EndValue = 22
},
new GanttChartActivity {
Name = "Foundations", StartValue = 24, EndValue = 30
},
new GanttChartActivity {
Name = "Brickwork", StartValue = 30, EndValue = 54
},
new GanttChartActivity {
Name = "Roof Timber", StartValue = 54, EndValue = 60
},
new GanttChartActivity {
Name = "Partitions", StartValue = 54, EndValue = 60
},
new GanttChartActivity {
Name = "Frames", StartValue = 54, EndValue = 64
},
new GanttChartActivity {
Name = "Roof Tiling", StartValue = 60, EndValue = 72
},
new GanttChartActivity {
Name = "First Fix", StartValue = 72, EndValue = 82
},
new GanttChartActivity {
Name = "Glazing", StartValue = 60, EndValue = 66
},
new GanttChartActivity {
Name = "Plaster", StartValue = 68, EndValue = 80
},
new GanttChartActivity {
Name = "Second Fix", StartValue = 80, EndValue = 92
},
new GanttChartActivity {
Name = "Interior Finish", StartValue = 88, EndValue = 100
},
new GanttChartActivity {
Name = "Cleanup", StartValue = 100, EndValue = 108
}
}
};
chart.AssertOutputEquals(
" Site Preparation | ===== 1 -> 10 (9)" + Environment.NewLine +
" Dig Trenches | == 12 -> 16 (4)" + Environment.NewLine +
" Drains | === 16 -> 22 (6)" + Environment.NewLine +
" Foundations | ==== 24 -> 30 (6)" + Environment.NewLine +
" Brickwork | ============= 30 -> 54 (24)" + Environment.NewLine +
" Roof Timber | === 54 -> 60 (6)" + Environment.NewLine +
" Partitions | === 54 -> 60 (6)" + Environment.NewLine +
" Frames | ====== 54 -> 64 (10)" + Environment.NewLine +
" Roof Tiling | ======= 60 -> 72 (12)" + Environment.NewLine +
" First Fix | ====== 72 -> 82 (10)" + Environment.NewLine +
" Glazing | ==== 60 -> 66 (6)" + Environment.NewLine +
" Plaster | ====== 68 -> 80 (12)" + Environment.NewLine +
" Second Fix | ======= 80 -> 92 (12)" + Environment.NewLine +
" Interior Finish | ======= 88 -> 100 (12)" + Environment.NewLine +
" Cleanup | ==== 100 -> 108 (8)" + Environment.NewLine +
" -------------------------------------------------------------" + Environment.NewLine,
"<pre><code>Site Preparation | ===== 1 -> 10 (9)\n" +
"Dig Trenches | == 12 -> 16 (4)\n" +
"Drains | === 16 -> 22 (6)\n" +
"Foundations | ==== 24 -> 30 (6)\n" +
"Brickwork | ============= 30 -> 54 (24)\n" +
"Roof Timber | === 54 -> 60 (6)\n" +
"Partitions | === 54 -> 60 (6)\n" +
"Frames | ====== 54 -> 64 (10)\n" +
"Roof Tiling | ======= 60 -> 72 (12)\n" +
"First Fix | ====== 72 -> 82 (10)\n" +
"Glazing | ==== 60 -> 66 (6)\n" +
"Plaster | ====== 68 -> 80 (12)\n" +
"Second Fix | ======= 80 -> 92 (12)\n" +
"Interior Finish | ======= 88 -> 100 (12)\n" +
"Cleanup | ==== 100 -> 108 (8)\n" +
" -------------------------------------------------------------\n" +
"</code></pre>\n\n"
);
}
public void TestCanPlotGanttChartWithNegativeActivities()
{
var chart = new GanttChart
{
Activities = new[]
{
new GanttChartActivity {
Name = "Both Negative", StartValue = -5, EndValue = -1
},
new GanttChartActivity {
Name = "Negative (zero length)", StartValue = -4, EndValue = -4
},
new GanttChartActivity {
Name = "Negative to Zero", StartValue = -4, EndValue = 0
},
new GanttChartActivity {
Name = "Negative to Positive", StartValue = -3, EndValue = 2
},
new GanttChartActivity {
Name = "Zero to Positive", StartValue = 0, EndValue = 3
},
new GanttChartActivity {
Name = "Zero to Zero", StartValue = 0, EndValue = 0
},
new GanttChartActivity {
Name = "Both Positive", StartValue = 1, EndValue = 3
},
new GanttChartActivity {
Name = "Both Negative (inverted)", StartValue = -1, EndValue = -5
},
new GanttChartActivity {
Name = "Zero to Negative", StartValue = 0, EndValue = -4
},
new GanttChartActivity {
Name = "Positive to Negative", StartValue = 2, EndValue = -3
},
new GanttChartActivity {
Name = "Positive to Zero", StartValue = 3, EndValue = 0
},
new GanttChartActivity {
Name = "Both Positive (inverted)", StartValue = 3, EndValue = 1
}
}
};
chart.AssertOutputEquals(
" Both Negative ==== | -5 -> -1 (4)" + Environment.NewLine +
" Negative (zero length) + | -4 -> -4 (0)" + Environment.NewLine +
" Negative to Zero ====| -4 -> 0 (4)" + Environment.NewLine +
" Negative to Positive ===|== -3 -> 2 (5)" + Environment.NewLine +
" Zero to Positive |=== 0 -> 3 (3)" + Environment.NewLine +
" Zero to Zero + 0 -> 0 (0)" + Environment.NewLine +
" Both Positive | == 1 -> 3 (2)" + Environment.NewLine +
" Both Negative (inverted) ==== | -1 -> -5 (4)" + Environment.NewLine +
" Zero to Negative ====| 0 -> -4 (4)" + Environment.NewLine +
" Positive to Negative ===|== 2 -> -3 (5)" + Environment.NewLine +
" Positive to Zero |=== 3 -> 0 (3)" + Environment.NewLine +
" Both Positive (inverted) | == 3 -> 1 (2)" + Environment.NewLine +
" ---------" + Environment.NewLine,
"<pre><code>Both Negative ==== | -5 -> -1 (4)\n" +
"Negative (zero length) + | -4 -> -4 (0)\n" +
"Negative to Zero ====| -4 -> 0 (4)\n" +
"Negative to Positive ===|== -3 -> 2 (5)\n" +
"Zero to Positive |=== 0 -> 3 (3)\n" +
"Zero to Zero + 0 -> 0 (0)\n" +
"Both Positive | == 1 -> 3 (2)\n" +
"Both Negative (inverted) ==== | -1 -> -5 (4)\n" +
"Zero to Negative ====| 0 -> -4 (4)\n" +
"Positive to Negative ===|== 2 -> -3 (5)\n" +
"Positive to Zero |=== 3 -> 0 (3)\n" +
"Both Positive (inverted) | == 3 -> 1 (2)\n" +
" ---------\n" +
"</code></pre>\n\n");
}
// Acción que determina que clase utilitzar para crear los "Charts"
public void CrearChart(Button button, Label label = null)
{
ClearLastElements();
BaseChart.Chart.Series.RemoveAllSeries();
//Themes.RefreshTheme();
Themes.BasicAxes(BaseChart.Chart.Axes.Left, BaseChart.Chart.Axes.Right);
Themes.AplicarTheme(BaseChart);
switch (button.Text)
{
case "Line":
lineChart = new LineChart(BaseChart);
break;
case "Column Bar":
columnBarChart = new ColumnBarChart(BaseChart);
break;
case "Area":
areaChart = new AreaChart(BaseChart);
break;
case "Pie":
pieChart = new PieChart(BaseChart);
break;
case "Fast Line":
fastLineChart = new FastLineChart(BaseChart);
break;
case "Horizontal Area":
horizAreaChart = new HorizontalAreaChart(BaseChart);
break;
case "Horizontal Bar":
horizBarChart = new HorizontalBarChart(BaseChart);
break;
case "Horizontal Line":
horizLineChart = new HorizontalLineChart(BaseChart);
break;
case "Donut":
donutChart = new DonutChart(BaseChart);
break;
case "Bubble":
bubbleChart = new BubbleChart(BaseChart);
break;
case "Shape":
shapeChart = new ShapeChart(BaseChart);
break;
case "Gantt":
gantChart = new GanttChart(BaseChart);
break;
case "Point/Scatter":
point_scatterChart = new Point_ScatterChart(BaseChart);
break;
case "Interpolating Line":
interpolatingChart = new InterpolatingChartFeatures(BaseChart);
break;
case "Bar Styles":
coneBarChart = new BarStylesChartFeatures(BaseChart);
break;
case "Zoom & Panning":
zoomPaningArrowChart = new ZoomPanningChartFeatures(BaseChart);
break;
case "Bar Gradient":
gradientBarChart = new GradientBarChartFeatures(BaseChart);
break;
case "Bubble Transparent":
bubbleTranspChart = new BubbleTransparencyChartFeatures(BaseChart);
break;
case "Real Time":
fLineRealTimeChart = new FLineRealTimeChartFeatures(BaseChart);
break;
case "Stack Area":
stackAreaChart = new StackAreaChartFeatures(BaseChart);
break;
case "Multiple Pies":
multiPiesChart = new MultiplePiesChartFeatures(BaseChart);
break;
case "Semi-Pie":
semiPieChart = new Semi_PieChartFeatures(BaseChart);
break;
case "Semi-Donut":
semiDonutChart = new Semi_DonutChartFeatures(BaseChart);
break;
case "Arrow":
arrowChart = new ArrowChart(BaseChart);
break;
case "Polar":
polarChart = new PolarChart(BaseChart);
break;
case "Radar":
radarChart = new RadarChart(BaseChart);
break;
case "Pyramid":
pyramidChart = new PyramidChart(BaseChart);
break;
case "Candle":
candleChart = new CandleChart(BaseChart);
break;
case "Histogram":
histogramChart = new HistogramChart(BaseChart);
break;
case "Error":
errorChart = new ErrorChart(BaseChart);
break;
case "ErrorBar":
errorBarChart = new ErrorBarChart(BaseChart);
break;
case "Funnel":
funnelChart = new FunnelChart(BaseChart);
break;
case "Smith":
smithChart = new SmithChart(BaseChart);
break;
case "Bezier":
bezierChart = new BezierChart(BaseChart);
break;
case "HighLow":
highLowChart = new HighLowChart(BaseChart);
break;
case "Speed Time":
realTimeChart = new SpeedTimeChart(BaseChart);
break;
case "Waterfall":
waterfallChart = new WaterfallChart(BaseChart);
break;
case "Volume":
volumeChart = new VolumeChart(BaseChart);
break;
case "Color Grid":
colorGridChart = new ColorGridChart(BaseChart);
break;
case "Polar Bar":
polarBarChart = new PolarBarChart(BaseChart);
break;
case "Inverted Pyramid":
invertedPyramidChart = new InvertedPyramidChart(BaseChart);
break;
case "Horizontal Histogram":
horizHistogramChart = new HorizHistogramChart(BaseChart);
break;
case "Circular Gauge":
basicCircGaugeChart = new BasicCircularGaugeChart(BaseChart);
break;
case "Car Fuel":
carFuelChart = new CarFuelChart(BaseChart);
break;
case "Custom Hand":
custPointerGaugeChart = new CustomPointerChart(BaseChart);
break;
case "Acceleration":
accelerationCircularGaugeChart = new AccelerationCircularGaugeChart(BaseChart);
break;
case "Knob Gauge":
basicKnobGaugeChart = new BasicKnobGaugeChart(BaseChart);
break;
case "Temperature Knob":
temperatureKnobChart = new TemperatureKnobChart(BaseChart);
break;
case "Compass":
try { compassChart = new CompassChart(BaseChart); }
catch (Exception e) { }
break;
case "Map GIS":
mapGSIChart = new MapGISChart(BaseChart);
break;
case "World Map":
worldMapChart = new WorldMapChart(BaseChart);
break;
case "TreeMap":
treeMapChart = new TreeMapChart(BaseChart);
break;
case "Basic Clock":
basicClockChart = new BasicClockChart(BaseChart);
break;
case "Custom Clock":
customClockChart = new CustomClockChart(BaseChart);
break;
case "Organizational Chart":
basicOrganizationalChart = new BasicOrganizationalChart(BaseChart);
break;
case "Numeric Gauge":
numericGaugeChart = new NumericGaugeChart(BaseChart);
break;
case "Linear Gauge":
linearGaugeChart = new LinearGaugeChart(BaseChart);
break;
case "Scales":
scalesLinearChart = new ScalesLinearChart(BaseChart);
break;
case "SubLines":
moreLinesLinearChart = new MoreLinesLinearChart(BaseChart);
break;
case "Mobile Battery":
batteryLinearChart = new BatteryLinearChart(BaseChart);
break;
case "Basic Calendar":
basicCalendarChart = new BasicCalendarChart(BaseChart, label);
break;
case "Special Dates":
specialDatesChart = new SpecialDatesChart(BaseChart, label);
break;
case "TagCloud":
tagCloudChart = new TagCloudChart(BaseChart);
break;
case "Add":
addStdFunctionsChart = new AddStdFunctionsChart(BaseChart);
break;
case "Subtract":
subtStdFunctionsChart = new SubtStdFunctionsChart(BaseChart);
break;
case "Multiply":
multStdFunctionsChart = new MultStdFunctionsChart(BaseChart);
break;
case "Divide":
divStdFunctionsChart = new DivStdFunctionsChart(BaseChart);
break;
case "Count":
countStdFunctionsChart = new CountStdFunctionsChart(BaseChart);
break;
case "Average":
avgStdFunctionsChart = new AvgStdFunctionsChart(BaseChart);
break;
case "High":
highStdFunctionsChart = new HighStdFunctionsChart(BaseChart);
break;
case "Low":
lowStdFunctionsChart = new LowStdFunctionsChart(BaseChart);
break;
case "Median Function":
medianStdFunctionsChart = new MedianStdFunctionsChart(BaseChart);
break;
case "Percent Change":
percentStdFunctionsChart = new PercentStdFunctionsChart(BaseChart);
break;
case "ADX":
adxProFunctionChart = new ADXProFunctionChart(BaseChart);
break;
case "AC":
acProFunctionChart = new ACProFunctionChart(BaseChart);
break;
case "Alligator":
alligatorProFunctionChart = new AlligatorProFunctionChart(BaseChart);
break;
case "AO":
aoProFunctionChart = new AOProFunctionChart(BaseChart);
break;
case "ATR":
atrProFunctionChart = new ATRProFunctionChart(BaseChart);
break;
case "Bollinger Bands":
bollingerProFunctionChart = new BollingerProFunctionChart(BaseChart);
break;
case "CCI":
cciProFunctionChart = new CCIProFunctionChart(BaseChart);
break;
case "CLV":
clvProFunctionChart = new CLVProFunctionChart(BaseChart);
break;
case "Compression OHLC":
compressionOHLCProFunctionChart = new CompressionOHLCProFunctionChart(BaseChart);
break;
case "Exp. Average":
expAverageProFunctionChart = new ExpAverageProFunctionChart(BaseChart);
break;
case "Exp. Moving Average":
expMovAverageProFunctionChart = new ExpMovAverageProFunctionChart(BaseChart);
break;
case "Gator Oscillator":
gatorOscillProFunctionChart = new GatorOscillProFunctionChart(BaseChart);
break;
case "Kurtosis":
kurtosisProFunctionChart = new KurtosisProFunctionChart(BaseChart);
break;
case "MACD":
macdProFunctionChart = new MACDProFunctionChart(BaseChart);
break;
case "Momentum":
momentumProFunctionChart = new MomentumProFunctionChart(BaseChart);
break;
case "Momentum Div.":
momentumDivProFunctionChart = new MomentumDivProFunctionChart(BaseChart);
break;
case "Money Flow":
moneyFlowProFunctionChart = new MoneyFlowProFunctionChart(BaseChart);
break;
case "OBV":
obvProFunctionChart = new OBVProFunctionChart(BaseChart);
break;
case "PVO":
pvoProFunctionChart = new PVOProFunctionChart(BaseChart);
break;
case "RSI":
rsiProFunctionChart = new RSIProFunctionChart(BaseChart);
break;
case "RVI":
rviProFunctionChart = new RVIProFunctionChart(BaseChart);
break;
case "Slope":
slopeProFunctionChart = new SlopeProFunctionChart(BaseChart);
break;
case "Smoothed Mov Avg":
smoothMovAvgProFunctionChart = new SmoothMovAvgProFunctionChart(BaseChart);
break;
case "S.A.R.":
sarProFunctionChart = new SARProFunctionChart(BaseChart);
break;
case "Cross Point":
crossPointsProFunctionsChart = new CrossPointsProFunctionsChart(BaseChart);
break;
case "Correlation":
correlationProFunctionChart = new CorrelationProFunctionChart(BaseChart);
break;
case "Cumulative":
cumulativeProFunctionChart = new CumulativeProFunctionChart(BaseChart);
break;
case "Custom Function":
calculateEventProFunctionChart = new CalculateEventProFunctionChart(BaseChart);
break;
case "Exponential Trend":
exponentialTrendProFunctionChart = new ExponentialTrendProFunctionChart(BaseChart);
break;
case "Fitting Linearizable":
fittingProFunctionChart = new FittingProFunctionChart(BaseChart);
break;
case "Performance":
performanceProFunctionChart = new PerformanceProFunctionChart(BaseChart);
break;
case "Perimeter":
perimeterProFunctionChart = new PerimeterProFunctionChart(BaseChart);
break;
case "Finding Coefficients":
findCoeffProFunctionChart = new FindCoeffProFunctionChart(BaseChart);
break;
case "Down Sampling":
downSamplingProFunctionChart = new DownSamplingProFunctionChart(BaseChart);
break;
case "RMS":
rmsProFunctionChart = new RMSProFunctionChart(BaseChart);
break;
case "Smoothing Function":
smoothingProFunctionChart = new SmoothingProFunctionChart(BaseChart);
break;
case "Standard Deviation":
stdDeviationProFunctionChart = new StdDeviationProFunctionChart(BaseChart);
break;
case "Trendline":
trendlineProFunctionChart = new TrendlineProFunctionChart(BaseChart);
break;
case "Variance":
varianceProFunctionChart = new VarianceProFunctionChart(BaseChart);
break;
case "SPC":
spcProFunctionChart = new SPCProFunctionChart(BaseChart);
break;
case "Cumulative Histogram":
cumulativeHistogProFunctionChart = new CumulativeHistogProFunctionChart(BaseChart);
break;
case "Skewness":
skewnessProFunctionChart = new SkewnessProFunctionChart(BaseChart);
break;
}
Themes.AplicarOptions(BaseChart);
}
private void Calculate(object sender, RoutedEventArgs e)
{
costs = CreateCostsMatrix(costs_TextBoxes);
lists = JohnsonAlgorithm.CreateLists(costs);
queue = JohnsonAlgorithm.ConnectLists(lists[0], lists[1]);
QueueList.Text = "Kolejka: " + String.Join(",", queue);
axis = JohnsonAlgorithm.CreateTasksAxis(costs, queue);
Axis1.Text = String.Join(" ", axis[0]);
Axis2.Text = String.Join(" ", axis[1]);
cost.Text = axis[1].Count.ToString();
Utilities.PlayFadeAnim(SBResult);
//GENERATE gannt list
int totalDuration = 0;
GanttRow machine1 = new GanttRow();
//Machine 1
for (int i = 0; i < queue.Count; i++)
{
Gantt gantt = new Gantt(totalDuration, costs[0, queue[i] - 1], queue[i].ToString());
machine1.elements.Add(gantt);
totalDuration += costs[0, queue[i] - 1];
}
//Machine 2
totalDuration = 0;
GanttRow machine2 = new GanttRow();
for (int i = 0; i < queue.Count; i++)
{
if (totalDuration > machine1.GetDurationTillEndOf(i + 1))
{
Gantt gantt = new Gantt(totalDuration, costs[1, queue[i] - 1], queue[i].ToString());
machine2.elements.Add(gantt);
totalDuration += costs[1, queue[i] - 1];
}
else
{
Gantt gantt = new Gantt(machine1.GetDurationTillEndOf(i + 1), costs[1, queue[i] - 1], queue[i].ToString());
machine2.elements.Add(gantt);
totalDuration = machine1.GetDurationTillEndOf(i + 1) + costs[1, queue[i] - 1];
}
}
try
{
machine2.FillEmptySpaces();
machine1.header = "Masz1";
machine2.header = "Masz2";
GanttChart ganttChart = new GanttChart();
ganttChart.rows.Add(machine1);
ganttChart.rows.Add(machine2);
ganttChart.DrawChart(ganttGrid);
}
catch (Exception ex)
{
Utilities.showErrorMessage(ex.Message);
}
}
public GanttChart GetDailyProduction(string cdate, int lineid) //date format : dd/MM/yyyy
{
DateTime startdate = Convert.ToDateTime(cdate);
DateTime enddate = Convert.ToDateTime(cdate).AddDays(1);
IList <OrderDetail> orderdetail = db.OrderDetails
//.Include(o => o.Line)
.Include(o => o.Product)
//.Include(o => o.Shift)
.Where(o => o.CreatedDate.Year == startdate.Year && o.CreatedDate.Month == startdate.Month && o.CreatedDate.Day == startdate.Day && o.LineId == lineid && o.FinalStatus == 1)
.OrderBy(x => x.OrderId).ToList();
var count = orderdetail.Count;
GanttChart objganttchart = new GanttChart();
objganttchart.type = "gantt";
objganttchart.width = "100%";
objganttchart.height = "120";
objganttchart.dataFormat = "json";
dataSource objdatasource = new dataSource();
//chart
chart objchart = new chart();
objchart.theme = "fusion";
objchart.dateformat = "dd/mm/yyyy hh:mn";
objchart.showTaskLabels = 1;
//task
gtask[] arrtask = new gtask[count];
for (int i = 0; i < count; i++)
{
var objtask = new gtask();
objtask.label = orderdetail[i].Product.ProductDesc;
objtask.processid = "A";
objtask.start = orderdetail[i].OrderStartTime.ToString("dd/MM/yyyy HH:mm");
DateTime endtime = orderdetail[i].OrderEndTime ?? DateTime.Now;
objtask.end = endtime.ToString("dd/MM/yyyy HH:mm");
objtask.color = "#" + orderdetail[i].Product.ProductColor;
objtask.alpha = "85";
arrtask[i] = objtask;
}
gtasks objtasks = new gtasks();
objtasks.task = arrtask;
//processes
processes objprocesses = new processes();
process[] arrprocess = new process[1];
process objprocess = new process();
objprocess.label = orderdetail[0].OrderStartTime.ToString("dd/MM/yyyy");
objprocess.id = "A";
arrprocess[0] = objprocess;
objprocesses.isbold = "1";
objprocesses.process = arrprocess;
//categories
categories[] arrcategories = new categories[1];
categories objcategories = new categories();
objcategories.bgalpha = "0";
//category1
category[] arrcategory1 = new category[1];
category objcategory1 = new category();
objcategory1.start = startdate.ToString("dd/MM/yyyy 06:00");
objcategory1.end = enddate.ToString("dd/MM/yyyy 06:00");
objcategory1.label = "";
arrcategory1[0] = objcategory1;
objcategories.category1 = arrcategory1;
//category
category[] arrcategory = new category[24];
int arrcategorycount = arrcategory.Length;
for (int i = 0; i < arrcategorycount; i++)
{
int k = i + 1;
int stime = 6 + i;
int etime = 6 + k;
int starttime = stime >= 24 ? stime - 24 : stime;
int endtime = etime >= 24 ? etime - 24 : etime;
string startimeformat = starttime.ToString().Length == 1 ? "0" + starttime.ToString() + ":00" : starttime.ToString() + ":00";
string endtimeformat = endtime.ToString().Length == 1 ? "0" + endtime.ToString() + ":00" : endtime.ToString() + ":00";
category objcategory = new category();
objcategory.start = stime >= 24 ? enddate.ToString("dd/MM/yyyy " + startimeformat + "") : startdate.ToString("dd/MM/yyyy " + startimeformat + "");
objcategory.end = stime >= 23 ? enddate.ToString("dd/MM/yyyy " + endtimeformat + "") : startdate.ToString("dd/MM/yyyy " + endtimeformat + "");
objcategory.label = startimeformat;
arrcategory[i] = objcategory;
}
objcategories.category = arrcategory;
arrcategories[0] = objcategories;
objdatasource.chart = objchart;
objdatasource.tasks = objtasks;
objdatasource.processes = objprocesses;
objdatasource.categories = arrcategories;
objganttchart.dataSource = objdatasource;
return(objganttchart);
}
/// <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, GanttChart chart)
: base(graphics, clipRect)
{
this.Chart = chart;
}
private static IChart CreateSampleChart(string caption)
{
var chart = new GanttChart
{
Caption = caption,
SubCaption = "소제목입니다.",
Palette = 2,
BaseFontAttr =
{
Font = "맑은 고딕",
FontColor = "#0372AB".FromHtml(),
FontSize = "8"
},
};
GanttUtil.GenerateCategories(chart.CategoriesList, ProjectPeriod, PeriodFlags.YearWeek);
chart.Processes.FontAttr.Font = "맑은 고딕";
chart.Processes.FontAttr.FontSize = 12.ToString();
chart.Processes.FontAttr.IsBold = true;
chart.Processes.FontAttr.IsItalic = false;
chart.Processes.Align = FusionTextAlign.Right;
chart.Processes.HeaderText = "What to do?";
chart.Processes.HeaderAttr.FontAttr.FontSize = 18.ToString();
chart.Processes.HeaderAttr.Align = FusionTextAlign.Left;
chart.Processes.HeaderAttr.VAlign = FusionVerticalAlign.Middle;
// task의 진행률을 Percentage로 나타낼 때, 완료하지 않은 부분
chart.SlackFillColor = Color.DarkGray;
// Task의 진행률을 나타냅니다.
chart.ShowPercentLabel = true;
var procId = 0;
foreach (string label in ProcessLabels)
{
var process = new ProcessElement("Process" + procId++)
{
ItemAttr =
{
Label = label,
FontAttr =
{
Font = "맑은 고딕",
FontColor = Color.FromArgb(0, 0x03, 0x72, 0xAB),
FontSize = 13.ToString(),
IsBold = true
}
}
};
// process.ItemAttr.FontAttr.IsItalic = true;
// process.ItemAttr.FontAttr.IsUnderline = true;
// process.ItemAttr.BgColor = Color.White;
process.ItemAttr.Align = FusionTextAlign.Left;
process.ItemAttr.VAlign = FusionVerticalAlign.Middle;
// chart.Processes.ProcessElements.Add(process);
chart.Processes.Add(process);
}
var taskId = 0;
foreach (var taskPeriod in TaskPeriods)
{
var task = new TaskElement
{
Start = taskPeriod.Start,
End = taskPeriod.End,
Id = taskId++.ToString(),
Color = Color.SteelBlue,
ShowLabel = true,
Animation = true,
BorderThickness = 1,
PercentComplete = rnd.Next(0, 101)
};
// Task의 진행률
// chart.Tasks.TaskElements.Add(task);
chart.Tasks.Add(task);
}
return(chart);
}
