private void CustomExport(object sender, CustomExportEventArgs e)
{
foreach (var printControl in e.GetPrintableControls())
{
if (printControl.Value is XRChart)
{
var pieItemName = printControl.Key;
IDashboardControl dashboardControl = (IDashboardControl)sender;
PieDashboardItem pieDashboardItem = dashboardControl.Dashboard.Items[pieItemName] as PieDashboardItem;
if (pieDashboardItem == null)
{
return;
}
XRChart pieChart = printControl.Value as XRChart;
if (pieChart == null || pieChart.Diagram == null)
{
return;
}
pieChart.Diagram.Tag = pieItemName;
pieChart.CustomizePieTotalLabel += (s, args) => {
string componentName = (s as XRChart).Diagram.Tag.ToString();
MultiDimensionalData data = e.GetItemData(componentName);
CustomizePieTotalLabel(componentName, data, args);
};
foreach (Series series in pieChart.Series)
{
(series.View as PieSeriesView).TotalLabel.Visible = true;
}
}
}
}
private void dashboardViewer1_DashboardItemElementCustomColor(object sender,
DashboardItemElementCustomColorEventArgs e)
{
MultiDimensionalData data = e.Data;
AxisPointTuple currentElement = e.TargetElement;
if (e.DashboardItemName == "chartDashboardItem1")
{
string country =
currentElement.GetAxisPoint(DashboardDataAxisNames.ChartSeriesAxis).Value.ToString();
decimal value = (decimal)(data.GetSlice(currentElement)).GetValue(e.Measures[0]).Value;
if (country == "UK" && value > 50000 || country == "USA" && value > 100000)
{
e.Color = Color.DarkGreen;
}
else
{
e.Color = Color.DarkRed;
}
}
if (e.DashboardItemName == "pieDashboardItem1")
{
decimal value =
(decimal)(data.GetSlice(currentElement)).GetValue(data.GetMeasures()[0]).Value;
if (value < 100000)
{
e.Color = Color.Orange;
}
}
}
// Obtains a value of the axis point placed on the "default" axis
// to display this value in the invoked form title.
string GetFormTitle(MultiDimensionalData clickedItemData)
{
AxisPoint clickedPoint = clickedItemData.GetAxisPoints(DashboardDataAxisNames.DefaultAxis)[0];
string clickedPointValue = clickedPoint.Value.ToString();
return(clickedPointValue);
}
private static void AddRowsByGridDashboardItem(GridDashboardItem gridItem, MultiDimensionalData mData, DataTable dataTable)
{
IList <string> axis = mData.GetAxisNames();
int rowCount = GetRowCount(mData, axis);
for (int i = 0; i < rowCount; i++)
{
AxisPoint point = mData.GetAxisPoints(axis[0])[i];
DataRow newRow = dataTable.NewRow();
foreach (GridColumnBase column in gridItem.Columns)
{
GridMeasureColumn mCol = column as GridMeasureColumn;
if (mCol != null)
{
newRow[mCol.Measure.DataMember] = GetMesureValue(mData, point, mCol);
}
GridDimensionColumn dCol = column as GridDimensionColumn;
if (dCol != null)
{
newRow[dCol.Dimension.DataMember] = GetDimenstionValue(mData, axis, point, dCol);
}
}
dataTable.Rows.Add(newRow);
}
}
void CustomizePieTotalLabel(string componentName, MultiDimensionalData data, CustomizePieTotalLabelEventArgs e)
{
PieTotalSettings settings = PieTotalSettings.FromJson(dashboardControl.Dashboard.Items[componentName].CustomProperties[customPropertyName]);
string resultText = string.Empty;
if (!string.IsNullOrEmpty(settings.Prefix))
{
resultText += settings.Prefix + Environment.NewLine;
}
MeasureDescriptor measure = data.GetMeasures().First();
if (!string.IsNullOrEmpty(settings.MeasureId) ||
data.GetMeasures().Where(m => m.ID == settings.MeasureId).Any())
{
measure = data.GetMeasures().FirstOrDefault(m => m.ID == settings.MeasureId);
}
if (measure != null)
{
AxisPoint axisPoint = e.Series.Tag as AxisPoint;
resultText += data.GetSlice(axisPoint).GetValue(measure).DisplayText;
}
if (!string.IsNullOrEmpty(settings.Postfix))
{
resultText += Environment.NewLine + settings.Postfix;
}
e.Text = resultText;
}
private static string GetOid(DashboardItemMouseActionEventArgs e)
{
MultiDimensionalData data = e.Data.GetSlice(e.GetAxisPoint());
MeasureDescriptor descriptor = data.GetMeasures().SingleOrDefault(item => item.DataMember == "Oid");
MeasureValue measureValue = data.GetValue(descriptor);
return(measureValue.Value.ToString());
}
AxisPoint EnsureInstancePoint(MultiDimensionalData data, AxisPoint axisPoint)
{
IEnumerable <DimensionDescriptor> axisDimensions = data.GetDimensions(axisPoint.AxisName);
DimensionDescriptor instanceDimension = axisDimensions.FirstOrDefault(dim => dim.ID == axisPoint.Dimension.ID);
IEnumerable <AxisPoint> points = data.GetAxisPointsByDimension(instanceDimension);
return(points.Single(p => p.Equals(axisPoint)));
}
private void DashboardViewer1_CustomizeDashboardItemCaption(object sender, CustomizeDashboardItemCaptionEventArgs e)
{
DashboardViewer viewer = (DashboardViewer)sender;
if (e.DashboardItemName == "pieDashboardItem1")
{
DashboardToolbarItem infoButton = new DashboardToolbarItem();
MultiDimensionalData mData = viewer.GetItemData(e.DashboardItemName);
var orderCount = mData.GetValue(mData.GetMeasures().Where(m => m.DataMember == "OrderID").First()).Value ?? 0;
e.FilterText += string.Format("{0:N0} distinct orders are displayed", orderCount);
}
}
public static void CustomExport(CustomExportWebEventArgs e)
{
Dictionary <string, XRControl> controls = e.GetPrintableControls();
foreach (var control in controls)
{
string componentName = control.Key;
XRChart chartControl = control.Value as XRChart;
ChartDashboardItem chartItem = e.GetDashboardItem(componentName) as ChartDashboardItem;
if (chartControl != null && chartItem != null)
{
string constantLinesJSON = chartItem.CustomProperties["ConstantLineSettings"];
if (constantLinesJSON != null)
{
XYDiagram diagram = chartControl.Diagram as XYDiagram;
if (diagram != null)
{
List <CustomConstantLine> customConstantLines = JsonConvert.DeserializeObject <List <CustomConstantLine> >(constantLinesJSON);
customConstantLines.ForEach(customConstantLine =>
{
ConstantLine line = new ConstantLine();
line.Visible = true;
line.ShowInLegend = false;
line.Color = ColorTranslator.FromHtml(customConstantLine.color);
line.Title.Text = customConstantLine.labelText;
line.LineStyle.DashStyle = DashStyle.Dash;
line.LineStyle.Thickness = 2;
if (customConstantLine.isBound)
{
MultiDimensionalData data = e.GetItemData(componentName);
MeasureDescriptor measure = data.GetMeasures().FirstOrDefault(m => m.ID == customConstantLine.measureId);
if (measure != null)
{
line.AxisValue = data.GetValue(measure).Value;
}
}
else
{
line.AxisValue = customConstantLine.value;
}
if (diagram.SecondaryAxesY.Count > 0)
{
diagram.SecondaryAxesY[0].ConstantLines.Add(line);
}
});
}
}
}
}
}
public static DataTable CreateDataTableByGridDashboardItem(GridDashboardItem gridItem, DashboardViewer viewer)
{
DataTable dataTable = null;
if (gridItem != null)
{
MultiDimensionalData mData = viewer.GetItemData(gridItem.ComponentName);
dataTable = new DataTable();
CreateColumnsByGridDashboardItem(gridItem, dataTable);
AddRowsByGridDashboardItem(gridItem, mData, dataTable);
}
return(dataTable);
}
private void DashboardItemControlCreated(object sender, DashboardItemControlEventArgs e)
{
if (e.ChartControl != null)
{
PieDashboardItem pieItem = dashboardControl.Dashboard.Items[e.DashboardItemName] as PieDashboardItem;
if (pieItem == null)
{
return;
}
e.ChartControl.CustomizePieTotalLabel += (s, args) => {
string componentName = (s as ChartControl).Diagram.Tag.ToString();
MultiDimensionalData data = dashboardControl.GetItemData(componentName);
CustomizePieTotalLabel(componentName, data, args);
};
}
}
public void ConfigureGantt(DashboardControl dashboardControl, string name)
{
Func <bool> func = () => dashboardControl.DashboardViewModel.GetItemModel(name).IsLoaded;
// Wait until the dashoard item data is ready and convert the data to the Gantt format.
Dispatcher dispatcher = Dispatcher.CurrentDispatcher;
bool result = false;
while (!result)
{
var operation = dispatcher.BeginInvoke(DispatcherPriority.SystemIdle, func);
operation.Wait();
result = (bool)operation.Result;
}
MultiDimensionalData data = dashboardControl.GetItemData(name);
GanttTasks = ConfigureGanttTasks(data);
}
// Converts data from a dashboard data model to the Gantt chart data model.
ObservableCollection <GanttTask> ConfigureGanttTasks(MultiDimensionalData data)
{
DimensionDescriptorCollection dimensions = data.GetDimensions(DashboardDataAxisNames.DefaultAxis);
MeasureDescriptorCollection measures = data.GetMeasures();
ReadOnlyCollection <AxisPoint> gridRows = data.GetAxisPoints(DashboardDataAxisNames.DefaultAxis);
ObservableCollection <GanttTask> tasks = new ObservableCollection <GanttTask>();
List <string> keys = new List <string>();
keys.Add("root");
foreach (AxisPoint row in gridRows)
{
string parentKey = "root";
foreach (DimensionDescriptor dimension in dimensions.Cast <DimensionDescriptor>())
{
string currentKey = parentKey + "|" + row.GetDimensionValue(dimension).DisplayText;
if (keys.Contains(currentKey))
{
GanttTask currentTask = tasks.Where(t => t.Id == keys.IndexOf(currentKey)).First();
DateTime start = (DateTime)data.GetSlice(row).GetValue(measures[0]).Value;
DateTime finish = (DateTime)data.GetSlice(row).GetValue(measures[1]).Value;
currentTask.Start = new DateTime(Math.Min(currentTask.Start.Ticks, start.Ticks));
currentTask.Finish = new DateTime(Math.Max(currentTask.Finish.Ticks, finish.Ticks));
}
else
{
keys.Add(currentKey);
data.GetSlice(row).GetValue(measures[0]);
tasks.Add(new GanttTask()
{
Id = keys.IndexOf(currentKey),
ParentId = keys.IndexOf(parentKey),
Name = row.GetDimensionValue(dimension).DisplayText,
Start = (DateTime)data.GetSlice(row).GetValue(measures[0]).Value,
Finish = (DateTime)data.GetSlice(row).GetValue(measures[1]).Value
});
}
parentKey = currentKey;
}
}
return(tasks);
}
// Handles the DashboardViewer.DashboardItemClick event.
private void dashboardViewer1_DashboardItemClick(object sender,
DashboardItemMouseActionEventArgs e)
{
if (e.DashboardItemName == "cardDashboardItem1" & e.GetAxisPoint() != null)
{
// Obtains client data related to the clicked card.
MultiDimensionalData clickedItemData = e.Data.GetSlice(e.GetAxisPoint());
DeltaDescriptor delta = e.GetDeltas()[0];
// Creates a data table that will be used to hold client data.
DataTable dataSource = new DataTable();
dataSource.Columns.Add("Argument", typeof(DateTime));
dataSource.Columns.Add("Actual", typeof(double));
dataSource.Columns.Add("Target", typeof(double));
// Saves values of axis points placed on the "sparkline" axis and corresponding
// actual/target values to the data table.
foreach (AxisPoint point in
clickedItemData.GetAxisPoints(DashboardDataAxisNames.SparklineAxis))
{
DataRow row = dataSource.NewRow();
DeltaValue deltaValue = clickedItemData.GetSlice(point).GetDeltaValue(delta);
if (deltaValue.ActualValue.Value != null &&
deltaValue.TargetValue.Value != null)
{
row["Argument"] = point.Value;
row["Actual"] = deltaValue.ActualValue.Value;
row["Target"] = deltaValue.TargetValue.Value;
}
else
{
row["Argument"] = DBNull.Value;
row["Actual"] = DBNull.Value;
row["Target"] = DBNull.Value;
}
dataSource.Rows.Add(row);
}
DisplayDetailedChart(GetFormTitle(clickedItemData), dataSource);
}
}
private static object GetDimenstionValue(MultiDimensionalData mData, IList <string> axis, AxisPoint point, GridDimensionColumn dCol)
{
return(point.GetDimensionValue(mData.GetDimensions(axis[0]).OfType <DimensionDescriptor>().First(d => d.DataMember == dCol.Dimension.DataMember)).Value);
}
private static int GetRowCount(MultiDimensionalData mData, IList <string> axis)
{
return(mData.GetAxisPoints(axis[0]).Count);
}
private static object GetMesureValue(MultiDimensionalData mData, AxisPoint point, GridMeasureColumn mCol)
{
return(mData.GetSlice(point).GetValue(mData.GetMeasures().OfType <MeasureDescriptor>().First(d => d.DataMember == mCol.Measure.DataMember)).Value);
}
