private void GenerateColumns()
{
// Create columns
ColumnDefinitions?.Clear();
for (int i = 0; i < ColumnCount; i++)
{
ColumnDefinitions?.Add(new ColumnDefinition()
{
Width = new GridLength(1, GridUnitType.Star)
});
}
}
public void BuildTiles(IEnumerable <object> tiles)
{
try
{
if (tiles == null || tiles.Count() == 0)
{
Children?.Clear();
}
var t = ItemsSource.GetType();
var isObs = t.GetTypeInfo().IsGenericType&& ItemsSource.GetType().GetGenericTypeDefinition() == typeof(ObservableCollection <>);
if (isObs)
{
ObservableSource = new ObservableCollection <object>(ItemsSource.Cast <object>());
}
// Wipe out the previous definitions if they're there.
RowDefinitions?.Clear();
ColumnDefinitions?.Clear();
var enumerable = ObservableSource as IList ?? tiles.ToList();
var numberOfRows = Math.Ceiling(enumerable.Count / (float)MaxColumns);
for (var i = 0; i < MaxColumns; i++)
{
ColumnDefinitions.Add(new ColumnDefinition {
Width = GridLength.Star
});
}
for (var i = 0; i < numberOfRows; i++)
{
RowDefinitions?.Add(new RowDefinition {
Height = TileHeight
});
}
for (var index = 0; index < enumerable.Count; index++)
{
var column = index % MaxColumns;
var row = (int)Math.Floor(index / (float)MaxColumns);
var tile = BuildTile(enumerable[index]);
Children.Add(tile, column, row);
}
//ForceLayout();
}
catch
{ // can throw exceptions if binding upon disposal
/*throw new Exception(" Unhandled excepection while building tiles");*/
}
}
public LinearLayout()
{
Orientation = LayoutSystemOrientation.HORIZONTAL;
ColumnDefinitions.Clear();
RowDefinitions.Clear();
}
public void ClearPanel()
{
ColumnDefinitions.Clear();
RowDefinitions.Clear();
}
protected void CreateComposite()
{
Children.Clear();
if (!GraphUtil.IsNullNumber <T>(MinValue) && !GraphUtil.IsNullNumber <T>(MaxValue))
{
IsRanged = true;
ColumnDefinitions.Clear();
ColumnDefinition col0 = new ColumnDefinition();
T test = default(T);
if (test is float)
{
col0.Width = new GridLength(UIWpf.GetHorizontalSizeOfCharacterString((int)Math.Ceiling(2 * Math.Log10(Math.Max(GraphUtil.ToInt <T>(MinValue), GraphUtil.ToInt <T>(MaxValue))))));
}
else
{
col0.Width = new GridLength(UIWpf.GetHorizontalSizeOfCharacterString((int)Math.Ceiling(Math.Log10(Math.Max(GraphUtil.ToInt <T>(MinValue), GraphUtil.ToInt <T>(MaxValue))))));
}
this.ColumnDefinitions.Add(col0);
ColumnDefinition col1 = new ColumnDefinition();
col1.Width = new GridLength(5);
this.ColumnDefinitions.Add(col1);
ColumnDefinition col2 = new ColumnDefinition();
col2.Width = new GridLength(1, GridUnitType.Star);
this.ColumnDefinitions.Add(col2);
TextBox = new TextBox();
Grid.SetColumn(TextBox, 0);
TextBox.TextChanged += new TextChangedEventHandler(OnBoxTextChanged);
Children.Add(TextBox);
Slider = new MySlider();
Slider.MinWidth = 60; //////////////////////////////////////// !!!!!!!!!!!
Slider.Minimum = GraphUtil.ToDouble <T>(MinValue);
Slider.Maximum = GraphUtil.ToDouble <T>(MaxValue);
Slider.IsSnapToTickEnabled = true;
Slider.Foreground = (Brush)FindResource("0GrayBrush");
Slider.TickFrequency = 1;
Slider.TickPlacement = TickPlacement.BottomRight;
Grid.SetColumn(Slider, 2);
Slider.ValueChanged += new RoutedPropertyChangedEventHandler <double>(OnSliderValueChanged);
if (Vertex.Get(@"BaseEdge:\Meta:\$UpdateAfterInteractionEnd:") != null)
{
Slider.FireValueChangedOnlyIfDraggingFinished = true;
}
Children.Add(Slider);
}
else
{
TextBox = new TextBox();
TextBox.TextChanged += new TextChangedEventHandler(OnBoxTextChanged);
Children.Add(TextBox);
}
}
public void GridShaping()
{
//罫線の太さはここで指定。
var thickness = new GridLength(1);
// 罫線用の行・列を追加
var columns = ColumnDefinitions.ToArray();
ColumnDefinitions.Clear();
if (columns.Any())
{
foreach (var c in columns)
{
ColumnDefinitions.Add(new ColumnDefinition {
Width = thickness
});
ColumnDefinitions.Add(c);
}
}
else
{
ColumnDefinitions.Add(new ColumnDefinition {
Width = thickness
});
ColumnDefinitions.Add(new ColumnDefinition());
}
ColumnDefinitions.Add(new ColumnDefinition {
Width = new GridLength(0.5)
});
var rows = RowDefinitions.ToArray();
RowDefinitions.Clear();
if (rows.Any())
{
foreach (var r in rows)
{
RowDefinitions.Add(new RowDefinition {
Height = thickness
});
RowDefinitions.Add(r);
}
}
else
{
RowDefinitions.Add(new RowDefinition {
Height = thickness
});
RowDefinitions.Add(new RowDefinition());
}
RowDefinitions.Add(new RowDefinition {
Height = thickness
});
//行・列を追加した分、Column,Row,ColumnSpan,RowSpanがずれるのでその補正再設定
foreach (UIElement c in Children)
{
SetColumn(c, GetColumn(c) * 2 + 1);
SetColumnSpan(c, GetColumnSpan(c) * 2 - 1);
SetRow(c, GetRow(c) * 2 + 1);
SetRowSpan(c, GetRowSpan(c) * 2 - 1);
}
//罫線用に追加した行・列にRectangleを配置
for (var i = 0; i < ColumnDefinitions.Count; i += 2)
{
var rectangle = new Rectangle()
{
Fill = Brushes.Black
};
Children.Add(rectangle);
SetColumn(rectangle, i);
SetRowSpan(rectangle, RowDefinitions.Count);
SetZIndex(rectangle, int.MinValue);
}
for (var i = 0; i < RowDefinitions.Count; i += 2)
{
var rectangle = new Rectangle()
{
Fill = Brushes.Black
};
Children.Add(rectangle);
SetRow(rectangle, i);
SetColumnSpan(rectangle, ColumnDefinitions.Count);
SetZIndex(rectangle, int.MinValue);
}
}
private void UpdateRowColDefinitions()
{
var root = _model.Root;
if (root == null)
{
return;
}
var manager = root.Manager;
if (manager == null)
{
return;
}
FixChildrenDockLengths();
//Debug.Assert(InternalChildren.Count == _model.ChildrenCount + (_model.ChildrenCount - 1));
#region Setup GridRows/Cols
RowDefinitions.Clear();
ColumnDefinitions.Clear();
if (Orientation == Orientation.Horizontal)
{
int iColumn = 0;
int iChild = 0;
for (int iChildModel = 0; iChildModel < _model.Children.Count; iChildModel++, iColumn++, iChild++)
{
var childModel = _model.Children[iChildModel] as ILayoutPositionableElement;
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = childModel.IsVisible ? childModel.DockWidth : new GridLength(0.0, GridUnitType.Pixel),
MinWidth = childModel.IsVisible ? childModel.CalculatedDockMinWidth() : 0.0
});
Grid.SetColumn(InternalChildren[iChild], iColumn);
//append column for splitter
if (iChild < InternalChildren.Count - 1)
{
iChild++;
iColumn++;
bool nextChildModelVisibleExist = false;
for (int i = iChildModel + 1; i < _model.Children.Count; i++)
{
var nextChildModel = _model.Children[i] as ILayoutPositionableElement;
if (nextChildModel.IsVisible)
{
nextChildModelVisibleExist = true;
break;
}
}
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = childModel.IsVisible && nextChildModelVisibleExist ? new GridLength(manager.GridSplitterWidth) : new GridLength(0.0, GridUnitType.Pixel)
});
Grid.SetColumn(InternalChildren[iChild], iColumn);
}
}
}
else //if (_model.Orientation == Orientation.Vertical)
{
int iRow = 0;
int iChild = 0;
for (int iChildModel = 0; iChildModel < _model.Children.Count; iChildModel++, iRow++, iChild++)
{
var childModel = _model.Children[iChildModel] as ILayoutPositionableElement;
RowDefinitions.Add(new RowDefinition()
{
Height = childModel.IsVisible ? childModel.DockHeight : new GridLength(0.0, GridUnitType.Pixel),
MinHeight = childModel.IsVisible ? childModel.CalculatedDockMinHeight() : 0.0
});
Grid.SetRow(InternalChildren[iChild], iRow);
//if (RowDefinitions.Last().Height.Value == 0.0)
// System.Diagnostics.Debugger.Break();
//append row for splitter (if necessary)
if (iChild < InternalChildren.Count - 1)
{
iChild++;
iRow++;
bool nextChildModelVisibleExist = false;
for (int i = iChildModel + 1; i < _model.Children.Count; i++)
{
var nextChildModel = _model.Children[i] as ILayoutPositionableElement;
if (nextChildModel.IsVisible)
{
nextChildModelVisibleExist = true;
break;
}
}
RowDefinitions.Add(new RowDefinition()
{
Height = childModel.IsVisible && nextChildModelVisibleExist ? new GridLength(manager.GridSplitterHeight) : new GridLength(0.0, GridUnitType.Pixel)
});
//if (RowDefinitions.Last().Height.Value == 0.0)
// System.Diagnostics.Debugger.Break();
Grid.SetRow(InternalChildren[iChild], iRow);
}
}
}
#endregion
}
public AutoLayoutGrid()
{
RowDefinitions.Clear();
ColumnDefinitions.Clear();
}
private void Clear()
{
ColumnDefinitions.Clear();
Children.Clear();
}
private void SetUI()
{
this.Dispatcher.Invoke(() =>
{
ColumnDefinitions.Clear();
RowDefinitions.Clear();
Children.Clear();
_cardControls.Clear();
// Set rows
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = new GridLength(2, GridUnitType.Star)
});
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = new GridLength(40, GridUnitType.Star)
});
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = new GridLength(40, GridUnitType.Star)
});
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = new GridLength(2, GridUnitType.Star)
});
int row = 0;
foreach (var cardIo in InternalCards)
{
RowDefinitions.Add(new RowDefinition()
{
Height = new GridLength(50)
});
// Create Background
var rect = new Rectangle()
{
Fill = Application.Current.Resources["SpectrumCardSide"] as Brush,
Margin = new Thickness(2)
};
SetColumn(rect, 0);
SetRow(rect, row);
Children.Add(rect);
rect = new Rectangle()
{
Fill = Application.Current.Resources["SpectrumCardDarkBackground"] as Brush,
Margin = new Thickness(2)
};
SetColumn(rect, 1);
SetRow(rect, row);
Children.Add(rect);
rect = new Rectangle()
{
Fill = Application.Current.Resources["SpectrumCardDarkBackground"] as Brush,
Margin = new Thickness(2)
};
SetColumn(rect, 2);
SetRow(rect, row);
Children.Add(rect);
rect = new Rectangle()
{
Fill = Application.Current.Resources["SpectrumCardSide"] as Brush,
Margin = new Thickness(2)
};
SetColumn(rect, 3);
SetRow(rect, row);
Children.Add(rect);
var control = new CardControl(cardIo);
control.OnClick += card =>
{
if (OnCardSelected != null)
{
OnCardSelected(card);
}
SelectedCard = card;
};
_cardControls.Add(control);
// Create Canvases
var canvas = new CustomCanvas(
(c) =>
{
c.Children.Add(control);
return(true);
},
(c) =>
{
var px = c.ActualWidth / 2000 * (cardIo.CenterFrequency - 100);
var size = c.ActualWidth / 2000 * 200;
control.Width = size;
control.Height = c.ActualHeight;
Canvas.SetLeft(control, px);
Canvas.SetTop(control, 0);
});
SetRow(canvas, row);
SetColumn(canvas, 1);
SetColumnSpan(canvas, 2);
Children.Add(canvas);
row += 1;
}
RowDefinitions.Add(new RowDefinition()
{
Height = new GridLength(25)
});
var zero = new Label {
Content = "0 Mhz", HorizontalAlignment = HorizontalAlignment.Left
};
Children.Add(zero);
SetColumn(zero, 1);
SetRow(zero, row);
var half = new Label
{
Content = "1000 Mhz",
HorizontalAlignment = HorizontalAlignment.Left,
Margin = new Thickness(-25, 0, 0, 0)
};
Children.Add(half);
SetColumn(half, 2);
SetRow(half, row);
var full = new Label {
Content = "2000 Mhz", HorizontalAlignment = HorizontalAlignment.Right
};
Children.Add(full);
SetColumn(full, 2);
SetRow(full, row);
ManageSelected(null, SelectedCard);
});
}
private void UpdateRowColumnInfo()
{
Children.Clear();
RowDefinitions.Clear();
ColumnDefinitions.Clear();
if (oldFirstSize == default(GridLength))
{
oldFirstSize = FirstChildRelativeSize;
}
if (oldSecondSize == default(GridLength))
{
oldSecondSize = SecondChildRelativeSize;
}
if (Orientation == Orientation.Horizontal)
{
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = oldFirstSize
});
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = separatorSize
});
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = oldSecondSize
});
RowDefinitions.Add(new RowDefinition());
SetRow(gridSplitter, 0);
SetColumn(gridSplitter, 1);
gridSplitter.ResizeDirection = GridResizeDirection.Columns;
gridSplitter.Width = 5;
gridSplitter.HorizontalAlignment = HorizontalAlignment.Stretch;
gridSplitter.VerticalAlignment = VerticalAlignment.Stretch;
}
else
{
RowDefinitions.Add(new RowDefinition()
{
Height = oldFirstSize
});
RowDefinitions.Add(new RowDefinition()
{
Height = separatorSize
});
RowDefinitions.Add(new RowDefinition()
{
Height = oldSecondSize
});
ColumnDefinitions.Add(new ColumnDefinition());
SetRow(gridSplitter, 1);
SetColumn(gridSplitter, 0);
gridSplitter.ResizeDirection = GridResizeDirection.Rows;
gridSplitter.Height = 5;
gridSplitter.HorizontalAlignment = HorizontalAlignment.Stretch;
gridSplitter.VerticalAlignment = VerticalAlignment.Stretch;
}
if (FirstChild != null)
{
SetRow(FirstChild, 0);
SetColumn(FirstChild, 0);
SetRowSpan(FirstChild, 1);
SetColumnSpan(FirstChild, 1);
Children.Add(FirstChild);
}
Children.Add(gridSplitter);
if (SecondChild != null)
{
if (Orientation == Orientation.Horizontal)
{
SetRow(SecondChild, 0);
SetColumn(SecondChild, 2);
}
else
{
SetRow(SecondChild, 2);
SetColumn(SecondChild, 0);
}
SetRowSpan(SecondChild, 1);
SetColumnSpan(SecondChild, 1);
Children.Add(SecondChild);
}
UpdateSplitterVisibility();
}
void RedoGridLayout()
{
// Get the amount to stagger the row start by.
var stagger = Stagger;
// The column to absorb the additional stagger amount.
var staggerFillColumn = -1;
// Count the number of column spans and find the index of the column to absorb any
// excess left by staggering the first column.
var columnSpans = (int)Math.Ceiling(stagger);
for (var index = 0; index < Children.Count; index++)
{
var child = (DependencyObject)Children[index];
var columnSpan = (int)child.GetValue(ColumnSpanProperty);
columnSpans += columnSpan;
}
// If no column marked to absorb any excess stagger amount...
if (staggerFillColumn == -1)
{
// ...and the excess to the last column.
staggerFillColumn = Children.Count - 1;
}
// We're going to rebuild to columns.
ColumnDefinitions.Clear();
var column = 0;
// If there's a stagger, emit an initial column.
if (stagger != 0)
{
AddStarColumn(stagger);
column++;
}
// Layout the columns.
for (var index = 0; index < Children.Count; index++)
{
var child = (DependencyObject)Children[index];
var columnSpan = (int)child.GetValue(ColumnSpanProperty);
var stars = 1.0;
if (index == staggerFillColumn)
{
stars += Math.Ceiling(stagger) - stagger;
}
AddStarColumn(stars);
child.SetValue(ColumnProperty, column);
column++;
// Add spanned columns.
for (var span = 1; span < columnSpan; span++)
{
AddStarColumn(1);
column++;
}
}
}
/// <summary>
/// Updates the panel.
/// </summary>
private void UpdatePanel()
{
if (!Children.Any(x => !_measured_childs.Contains(x)))
{
return;
}
RowDefinitions.Clear();
ColumnDefinitions.Clear();
if (Orientation == Orientation.Vertical)
{
for (int i = 0; i < Children.Count; i++)
{
FrameworkElement element = Children[i] as FrameworkElement;
_measured_childs.Add(element);
if (i < Children.Count - 1)
{
RowDefinitions.Add(new RowDefinition()
{
Height = new GridLength(1, GridUnitType.Star)
});
Grid.SetRow(element, i);
//if (element.DataContext is GraphAxisTickData)
//{
// (element.DataContext as GraphAxisTickData).Row = i;
//}
element.VerticalAlignment = VerticalAlignment.Top;
element.SizeChanged += (_, __) =>
{
element.Margin = new Thickness(0, (element.ActualHeight / 2) * -1, 0, 0);
};
}
else
{
Grid.SetRow(element, i);
//if (element.DataContext is GraphAxisTickData)
//{
// (element.DataContext as GraphAxisTickData).Row = i;
//}
element.VerticalAlignment = VerticalAlignment.Bottom;
element.SizeChanged += (_, __) =>
{
element.Margin = new Thickness(0, 0, 0, (element.ActualHeight / 2) * -1);
};
}
}
}
else
{
for (int i = 0; i < Children.Count; i++)
{
FrameworkElement element = Children[i] as FrameworkElement;
_measured_childs.Add(element);
if (i < Children.Count - 1)
{
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = new GridLength(1, GridUnitType.Star)
});
Grid.SetColumn(element, i);
element.HorizontalAlignment = HorizontalAlignment.Left;
//if (element.DataContext is GraphAxisTickData)
//{
// (element.DataContext as GraphAxisTickData).Column = i;
//}
element.SizeChanged += (_, __) =>
{
element.Margin = new Thickness((element.ActualWidth / 2) * -1, 0, 0, 0);
};
}
else
{
Grid.SetColumn(element, i);
element.HorizontalAlignment = HorizontalAlignment.Right;
//if (element.DataContext is GraphAxisTickData)
//{
// (element.DataContext as GraphAxisTickData).Column = i;
//}
element.SizeChanged += (_, __) =>
{
element.Margin = new Thickness(0, 0, (element.ActualWidth / 2) * -1, 0);
};
}
}
}
}
void UpdateChildren()
{
List <string> variables;
List <string> results;
Dictionary <string, List <string> > varValues;
var useResults = MultiRow ? Math.Max(0, (int)((ActualHeight - Spacing * 2) / RowHeight - 1)) : MaxResults;
try
{
var expression = new NEExpression(Expression);
variables = new List <string>(expression.Variables);
var resultCount = Math.Min(NumResults ?? ResultCount, useResults);
results = expression.EvaluateList <string>(Variables, resultCount).Coalesce("").ToList();
varValues = variables.ToDictionary(variable => variable, variable => Variables.GetValues(variable, resultCount).Select(val => val?.ToString()).ToList());
IsValid = true;
ErrorMessage = null;
}
catch (Exception ex)
{
results = MultiRow ? Enumerable.Repeat(default(string), useResults).ToList() : new List <string>();
variables = new List <string>();
varValues = new Dictionary <string, List <string> >();
IsValid = false;
ErrorMessage = ex.Message;
if ((Children.Count != 0) || (ActualHeight == 0) || (ActualWidth == 0))
{
return;
}
}
Children.Clear();
ColumnDefinitions.Clear();
RowDefinitions.Clear();
Func <WidthType, int, Tuple <WidthType, List <FrameworkElement> > > GetLine = (widthType, numRows) => Tuple.Create(widthType, Enumerable.Range(0, numRows).Select(row => new Rectangle {
Width = Spacing, Fill = BackColor
}).Cast <FrameworkElement>().ToList());
var columns = new List <Tuple <WidthType, List <FrameworkElement> > >();
if (MultiRow)
{
Func <WidthType, int, Tuple <WidthType, List <FrameworkElement> > > GetSpace = (widthType, numRows) => Tuple.Create(widthType, new[] { new Rectangle {
Width = Spacing, Fill = BackColor
} }.Concat(Enumerable.Range(0, numRows - 1).Select(row => new Rectangle {
Width = Spacing
})).Cast <FrameworkElement>().ToList());
columns.Add(GetLine(WidthType.None, results.Count + 1));
columns.AddRange(variables.SelectMany(variable => new[] {
GetSpace(WidthType.Shrink3, results.Count + 1),
Tuple.Create(WidthType.Expand | WidthType.Shrink4, new[] { GetTextBlock(variable, BackColor) }.Concat(Enumerable.Range(0, results.Count).Select(result => GetTextBlock(varValues[variable][result]))).ToList()),
GetSpace(WidthType.Shrink3, results.Count + 1),
GetLine(WidthType.Shrink5, results.Count + 1),
}));
if (!variables.Any())
{
columns.Add(GetSpace(WidthType.Shrink3, results.Count + 1));
columns.Add(Tuple.Create(WidthType.Expand | WidthType.Shrink4, new[] { GetTextBlock("", BackColor) }.Concat(results.Select(result => GetTextBlock("<No vars>"))).ToList()));
columns.Add(GetSpace(WidthType.Shrink3, results.Count + 1));
columns.Add(GetLine(WidthType.Shrink5, results.Count + 1));
}
columns.Add(Tuple.Create(WidthType.Shrink1, new[] { default(TextBlock) }.Concat(results.Select(result => GetTextBlock(" => "))).ToList()));
columns.Add(GetLine(WidthType.Shrink2, results.Count + 1));
columns.Add(Tuple.Create(WidthType.Shrink6, new[] { new Rectangle {
Width = Spacing, Fill = BackColor
} }.Concat(Enumerable.Repeat(default(FrameworkElement), results.Count)).ToList()));
columns.Add(Tuple.Create(WidthType.Expand | WidthType.Shrink7, new[] { GetTextBlock("Result", BackColor) }.Concat(results.Select(result => GetTextBlock(result))).ToList()));
columns.Add(Tuple.Create(WidthType.Shrink6, new[] { new Rectangle {
Width = Spacing, Fill = BackColor
} }.Concat(Enumerable.Repeat(default(FrameworkElement), results.Count)).ToList()));
columns.Add(GetLine(WidthType.None, results.Count + 1));
}
else
{
Func <WidthType, Tuple <WidthType, List <FrameworkElement> > > GetSpace = widthType => Tuple.Create(widthType, new[] { new Rectangle {
Width = Spacing
} }.Cast <FrameworkElement>().ToList());
columns.Add(GetLine(WidthType.None, 1));
if (results.Count == 0)
{
columns.Add(Tuple.Create(WidthType.Expand | WidthType.Shrink1, new List <FrameworkElement> {
default(FrameworkElement)
}));
columns.Add(GetLine(WidthType.None, 1));
}
else
{
columns.AddRange(results.SelectMany(result => new[] {
GetSpace(WidthType.Shrink1),
Tuple.Create(WidthType.Expand | WidthType.Shrink2, new List <FrameworkElement> {
GetTextBlock(result)
}),
GetSpace(WidthType.Shrink1),
GetLine(WidthType.Shrink3, 1),
}).ToList());
}
}
// Sanity check: should have same number on all columns
if (columns.Select(column => column.Item2.Count).Distinct().Count() != 1)
{
throw new Exception("Column counts don't match");
}
// Measure everything
var margin = new Thickness(0);
var size = new Size(double.PositiveInfinity, double.PositiveInfinity);
columns.SelectMany(column => column.Item2).Where(element => element != null).ForEach(element => { element.Margin = margin; element.Measure(size); });
const int precision = 10000;
var widths = columns.Select(column => (int)(column.Item2.Max(text => text?.DesiredSize.Width * precision) ?? 0)).ToList();
var available = Math.Max(0, (int)ActualWidth * precision);
// Expand as necessary
var expandIndexes = columns.Indexes(column => column.Item1.HasFlag(WidthType.Expand)).ToList();
var extraPerColumn = (available - widths.Sum()) / expandIndexes.Count;
if (extraPerColumn > 0)
{
expandIndexes.ForEach(index => widths[index] += extraPerColumn);
}
// Shrink as necessary
var shrinks = new[] { WidthType.Shrink1, WidthType.Shrink2, WidthType.Shrink3, WidthType.Shrink4, WidthType.Shrink5, WidthType.Shrink6, WidthType.Shrink7 };
foreach (var shrink in shrinks)
{
var shrinkIndexes = columns.Indexes(column => column.Item1.HasFlag(shrink)).ToList();
while ((widths.Sum() > available) && (shrinkIndexes.Any(index => widths[index] != 0)))
{
var shrinkWidths = shrinkIndexes.Select(column => widths[column]).OrderByDescending().Distinct().ToList();
var maxIndexes = shrinkIndexes.Where(column => widths[column] == shrinkWidths[0]).ToList();
var minWidth = shrinkWidths.Count > 1 ? shrinkWidths[1] : 0;
var extraPerIndex = (widths.Sum() - available + maxIndexes.Count - 1) / maxIndexes.Count;
maxIndexes.ForEach(column => widths[column] = Math.Max(minWidth, widths[column] - extraPerIndex));
}
}
var rows = columns[0].Item2.Count;
RowDefinitions.Add(new RowDefinition {
Height = new GridLength(Spacing)
});
for (var row = 0; row < rows; ++row)
{
RowDefinitions.Add(new RowDefinition {
Height = new GridLength(RowHeight)
});
}
RowDefinitions.Add(new RowDefinition {
Height = new GridLength(Spacing)
});
for (var column = 0; column < columns.Count; ++column)
{
ColumnDefinitions.Add(new ColumnDefinition {
Width = new GridLength((double)widths[column] / precision)
});
for (var row = 0; row < rows; ++row)
{
AddChild(columns[column].Item2[row], row + 1, column);
}
}
AddChild(new Rectangle {
Fill = BackColor, Height = Spacing
}, 0, 0, columnSpan: ColumnDefinitions.Count);
AddChild(new Rectangle {
Fill = BackColor, Height = Spacing
}, RowDefinitions.Count - 1, 0, columnSpan: ColumnDefinitions.Count);
GetErrorControls().ForEach(control => AddChild(control, 0, 0, RowDefinitions.Count, ColumnDefinitions.Count));
}
/// <summary>
/// Updates the panel.
/// </summary>
public void UpdatePanel()
{
RowDefinitions.Clear();
ColumnDefinitions.Clear();
if (Orientation == Orientation.Vertical)
{
for (int i = 0; i < InternalChildren.Count; i++)
{
FrameworkElement element = InternalChildren[i] as FrameworkElement;
if (i < InternalChildren.Count - 1)
{
RowDefinitions.Add(new RowDefinition()
{
Height = new GridLength(1, GridUnitType.Star)
});
Grid.SetRow(element, i);
element.VerticalAlignment = VerticalAlignment.Top;
element.SizeChanged += (_, __) =>
{
element.Margin = new Thickness(0, (element.ActualHeight / 2) * -1, 0, 0);
};
}
else
{
Grid.SetRow(element, i);
element.VerticalAlignment = VerticalAlignment.Bottom;
element.SizeChanged += (_, __) =>
{
element.Margin = new Thickness(0, 0, 0, (element.ActualHeight / 2) * -1);
};
}
}
}
else
{
for (int i = 0; i < InternalChildren.Count; i++)
{
FrameworkElement element = InternalChildren[i] as FrameworkElement;
if (i < InternalChildren.Count - 1)
{
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = new GridLength(1, GridUnitType.Star)
});
Grid.SetColumn(element, i);
element.HorizontalAlignment = HorizontalAlignment.Left;
element.SizeChanged += (_, __) =>
{
element.Margin = new Thickness((element.ActualWidth / 2) * -1, 0, 0, 0);
};
}
else
{
Grid.SetColumn(element, i);
element.HorizontalAlignment = HorizontalAlignment.Right;
element.SizeChanged += (_, __) =>
{
element.Margin = new Thickness(0, 0, (element.ActualWidth / 2) * -1, 0);
};
}
}
}
}
void buildTable()
{
Debug.WriteLine("[buildTable() started]");
if (columnSource == null || rowsSource == null)
{
return;
}
//clear table
Children.Clear();
ColumnDefinitions.Clear();
RowDefinitions.Clear();
RowDefinitions.Add(new RowDefinition
{
Height = new GridLength(1, GridUnitType.Auto),
});
var x = 0;
//process columns
foreach (var column in columnSource)
{
var headerCell = new ContentControl();
headerCell.HorizontalAlignment = HorizontalAlignment.Stretch;
headerCell.HorizontalContentAlignment = HorizontalAlignment.Stretch;
//apply first header template if first header column and first cell template supplied
if (x == 0 && firstHeaderTemplate != null)
{
headerCell.ContentTemplate = firstHeaderTemplate;
}
else
{
headerCell.ContentTemplate = headerTemplate;
}
headerCell.Content = column.Header;
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = new GridLength(1, column.IsAutoWidth ? GridUnitType.Auto : GridUnitType.Star),
});
SetColumn(headerCell, x);
SetRow(headerCell, 0);
Children.Add(headerCell);
var y = 1;
//process rows
foreach (var row in rowsSource)
{
var rowCell = new ContentControl();
rowCell.HorizontalAlignment = HorizontalAlignment.Stretch;
rowCell.HorizontalContentAlignment = HorizontalAlignment.Stretch;
//apply first header template if first header column and first cell template supplied
if (x == 0 && firstCellTemplate != null)
{
rowCell.ContentTemplate = firstCellTemplate;
}
else
{
rowCell.ContentTemplate = cellTemplate;
}
rowCell.DataContext = row;
BindingOperations.SetBinding(rowCell, ContentControl.ContentProperty, column.CellDataBinding);
if (RowDefinitions.Count - 1 < y)
{
RowDefinitions.Add(new RowDefinition()
{
Height = new GridLength(1, GridUnitType.Auto),
});
}
SetColumn(rowCell, x);
SetRow(rowCell, y);
Children.Add(rowCell);
y++;
}
x++;
}
Debug.WriteLine("[buildTable() completed]");
}
protected void UpdateControls()
{
ColumnDefinitions.Clear();
RowDefinitions.Clear();
if (Children.Count == 0)
{
return;
}
GridLength gr;
if (Orientation == LayoutOrientation.Horizontal)
{
gr = HorizontalOptions.Alignment == LayoutAlignment.Fill ? GridLength.Star : GridLength.Auto;
RowDefinitions.Add(new RowDefinition {
Height = ButtonHeight > 0 ? ButtonHeight : GridLength.Auto
});
RowDefinitions.Add(new RowDefinition {
Height = SelectorSize
});
}
else
{
gr = VerticalOptions.Alignment == LayoutAlignment.Fill ? GridLength.Star : GridLength.Auto;
ColumnDefinitions.Add(new ColumnDefinition {
Width = SelectorSize
});
ColumnDefinitions.Add(new ColumnDefinition {
Width = ButtonWidth > 0 ? ButtonWidth : GridLength.Star
});
}
for (int i = 0; i < Children.Count; i++)
{
var child = Children[i] as TabButton;
if (child == null)
{
continue;
}
child.HorizontalOptions = ButtonWidth > 0 ? LayoutOptions.Fill : HorizontalOptions.Alignment == LayoutAlignment.Fill ? LayoutOptions.Fill : LayoutOptions.CenterAndExpand;
child.VerticalOptions = ButtonHeight > 0 ? LayoutOptions.Fill : VerticalOptions.Alignment == LayoutAlignment.Fill ? LayoutOptions.Fill : LayoutOptions.CenterAndExpand;
if (Orientation == LayoutOrientation.Horizontal)
{
ColumnDefinitions.Add(new ColumnDefinition {
Width = ButtonWidth > 0 ? ButtonWidth : gr
});
Grid.SetColumn(child, i);
Grid.SetRow(child, 0);
// collapse cells if the children are invisible
if (!child.IsVisible)
{
ColumnDefinitions[i].Width = 0;
}
}
else
{
RowDefinitions.Add(new RowDefinition {
Height = ButtonHeight > 0 ? ButtonHeight : gr
});
Grid.SetColumn(child, 1);
Grid.SetRow(child, i);
// collapse cells if the children are invisible
if (!child.IsVisible)
{
RowDefinitions[i].Height = 0;
}
}
}
// NOTE: we can't change selector children add/remove during collectionchanged event
InvokeSelector();
}
public void Render(int width)
{
DataWidth = width;
_N.SetNewWidth(width);
Children.Clear();
ColumnDefinitions.Clear();
Width = CalcPanelWidth(DataWidth);
Label hexLb = new Label();
hexLb.Content = "HEX: ";
hexLb.HorizontalAlignment = HorizontalAlignment.Right;
Label decLb = new Label();
decLb.Content = "DEC: ";
decLb.HorizontalAlignment = HorizontalAlignment.Right;
TextBox hexTb = new TextBox();
hexTb.Text = _N.ToString("X");
TextBox decTb = new TextBox();
decTb.Text = _N.ToString("D");
int hexLbStart = 0;
int hexLbWidth = Min(3, width / 3);
int hexTbStart = hexLbStart + hexLbWidth;
int hexTbWidth = Min(8, width / 3);
int decLbStart = hexTbStart + hexTbWidth;
int decLbWidth = Min(3, width / 3);
int decTbStart = decLbStart + decLbWidth;
int decTbWidth = hexTbWidth;
SetRow(hexLb, 0);
SetRow(hexTb, 0);
SetRow(decLb, 0);
SetRow(decTb, 0);
SetColumn(hexLb, hexLbStart);
SetColumnSpan(hexLb, hexLbWidth);
SetColumn(hexTb, hexTbStart);
SetColumnSpan(hexTb, hexTbWidth);
SetColumn(decLb, decLbStart);
SetColumnSpan(decLb, decLbWidth);
SetColumn(decTb, decTbStart);
SetColumnSpan(decTb, decTbWidth);
Children.Add(hexLb);
Children.Add(hexTb);
Children.Add(decLb);
Children.Add(decTb);
hexTb.KeyDown += HexTb_KeyDown;
hexTb.TextChanged += HexTb_TextChanged;
decTb.KeyDown += DecTb_KeyDown;
decTb.TextChanged += DecTb_TextChanged;
for (int i = 0; i < DataWidth; i += 1)
{
Label lb = new Label();
lb.Content = (width - 1 - i).ToString();
lb.VerticalContentAlignment = VerticalAlignment.Center;
lb.HorizontalContentAlignment = HorizontalAlignment.Center;
lb.Height = _LabelHeight;
lb.Width = _LabelWidth;
SetColumn(lb, i);
SetRow(lb, 1);
TextBox tb = new TextBox();
tb.Text = _N.GetBit(i).ToString();
if (tb.Text == "1")
{
tb.Background = _TextBoxOneBg;
}
else
{
tb.Background = _TextBoxZeroBg;
}
tb.HorizontalContentAlignment = HorizontalAlignment.Center;
tb.VerticalContentAlignment = VerticalAlignment.Center;
tb.Height = _TextBoxHeight;
tb.Width = _TextBoxWidth;
tb.Tag = (width - 1 - i).ToString();
tb.Margin = new Thickness(_TextBoxLeftMargin, _TextBoxTopMargin, _TextBoxRightMargin, _TextBoxBottomMargin);
tb.KeyDown += OnTextBoxKeyPress;
tb.PreviewMouseDown += OnTextBoxMouseClick;
ColumnDefinition col = new ColumnDefinition();
ColumnDefinitions.Add(col);
SetColumn(tb, i);
SetRow(tb, 2);
Children.Add(tb);
Children.Add(lb);
}
if (_DecTbEdit == true)
{
_DecTbEdit = false;
decTb.Focus();
decTb.SelectionStart = decTb.Text.Length;
}
if (_HexTbEdit == true)
{
_HexTbEdit = false;
hexTb.Focus();
hexTb.SelectionStart = hexTb.Text.Length;
}
}
private void UpdateRowColumnInfo()
{
Children.Clear();
RowDefinitions.Clear();
ColumnDefinitions.Clear();
if (Orientation == Orientation.Horizontal)
{
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = new GridLength(1.0, GridUnitType.Star)
});
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = new GridLength(5)
});
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = new GridLength(3.0, GridUnitType.Star)
});
RowDefinitions.Add(new RowDefinition());
SetRow(gridSplitter, 0);
SetColumn(gridSplitter, 1);
gridSplitter.ResizeDirection = GridResizeDirection.Columns;
gridSplitter.Width = 5;
gridSplitter.HorizontalAlignment = HorizontalAlignment.Stretch;
gridSplitter.VerticalAlignment = VerticalAlignment.Stretch;
}
else
{
RowDefinitions.Add(new RowDefinition()
{
Height = new GridLength(1.0, GridUnitType.Star)
});
RowDefinitions.Add(new RowDefinition()
{
Height = new GridLength(5)
});
RowDefinitions.Add(new RowDefinition()
{
Height = new GridLength(50)
});
ColumnDefinitions.Add(new ColumnDefinition());
SetRow(gridSplitter, 1);
SetColumn(gridSplitter, 0);
gridSplitter.ResizeDirection = GridResizeDirection.Rows;
gridSplitter.Height = 5;
gridSplitter.HorizontalAlignment = HorizontalAlignment.Stretch;
gridSplitter.VerticalAlignment = VerticalAlignment.Stretch;
}
if (FirstChild != null)
{
SetRow(FirstChild, 0);
SetColumn(FirstChild, 0);
SetRowSpan(FirstChild, 1);
SetColumnSpan(FirstChild, 1);
Children.Add(FirstChild);
}
Children.Add(gridSplitter);
if (SecondChild != null)
{
if (Orientation == Orientation.Horizontal)
{
SetRow(SecondChild, 0);
SetColumn(SecondChild, 2);
}
else
{
SetRow(SecondChild, 2);
SetColumn(SecondChild, 0);
}
SetRowSpan(SecondChild, 1);
SetColumnSpan(SecondChild, 1);
Children.Add(SecondChild);
}
}
void UpdateRowColDefinitions()
{
var root = _model.Root;
if (root == null)
{
return;
}
var manager = root.Manager;
if (manager == null)
{
return;
}
FixChildrenDockLengths();
#region Setup GridRows/Cols
RowDefinitions.Clear();
ColumnDefinitions.Clear();
if (Orientation == Orientation.Horizontal)
{
int iColumn = 0;
int iChild = 0;
for (int iChildModel = 0; iChildModel < _model.Children.Count; iChildModel++, iColumn++, iChild++)
{
var childModel = _model.Children[iChildModel] as ILayoutPositionableElement;
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = childModel.IsVisible ? childModel.DockWidth : new GridLength(0.0, GridUnitType.Pixel),
MinWidth = childModel.IsVisible ? childModel.DockMinWidth : 0.0
});
Grid.SetColumn(InternalChildren[iChild], iColumn);
//append column for splitter
if (iChild < InternalChildren.Count - 1)
{
iChild++;
iColumn++;
ColumnDefinitions.Add(new ColumnDefinition()
{
Width = new GridLength(manager.GridSplitterWidth)
});
Grid.SetColumn(InternalChildren[iChild], iColumn);
bool nextChildModelVisibleExist = false;
if (childModel.IsVisible && !childModel.IsDockWidthFixed)
{
for (int i = iChildModel + 1; i < _model.Children.Count; i++)
{
var nextChildModel = _model.Children[i] as ILayoutPositionableElement;
if (nextChildModel.IsVisible && nextChildModel.DockWidth != GridLength.Auto && !nextChildModel.IsDockWidthFixed)
{
nextChildModelVisibleExist = true;
break;
}
}
}
InternalChildren[iChild].Visibility = nextChildModelVisibleExist ? Visibility.Visible : Visibility.Collapsed;
}
}
}
else //if (_model.Orientation == Orientation.Vertical)
{
int iRow = 0;
int iChild = 0;
for (int iChildModel = 0; iChildModel < _model.Children.Count; iChildModel++, iRow++, iChild++)
{
var childModel = _model.Children[iChildModel] as ILayoutPositionableElement;
RowDefinitions.Add(new RowDefinition()
{
Height = childModel.IsVisible ? childModel.DockHeight : new GridLength(0.0, GridUnitType.Pixel),
MinHeight = childModel.IsVisible ? childModel.DockMinHeight : 0.0
});
Grid.SetRow(InternalChildren[iChild], iRow);
//append row for splitter (if necessary)
if (iChild < InternalChildren.Count - 1)
{
iChild++;
iRow++;
RowDefinitions.Add(new RowDefinition()
{
Height = new GridLength(manager.GridSplitterHeight)
});
Grid.SetRow(InternalChildren[iChild], iRow);
bool nextChildModelVisibleExist = false;
if (childModel.IsVisible && !childModel.IsDockHeightFixed)
{
for (int i = iChildModel + 1; i < _model.Children.Count; i++)
{
var nextChildModel = _model.Children[i] as ILayoutPositionableElement;
if (nextChildModel.IsVisible && nextChildModel.DockHeight != GridLength.Auto && !nextChildModel.IsDockHeightFixed)
{
nextChildModelVisibleExist = true;
break;
}
}
}
InternalChildren[iChild].Visibility = nextChildModelVisibleExist ? Visibility.Visible : Visibility.Collapsed;
}
}
}
#endregion
}
private void RepopulateChildren(ObservableCollection <ObservableCollection <CellContent> > data)
{
//Debug.WriteLine("RepopulateChildren called.");
bool origRecursiveUpdates = PreventRecursiveUpdates;
PreventRecursiveUpdates = true;
Children.Clear();
RowDefinitions.Clear();
ColumnDefinitions.Clear();
var contextMenu = ParentWindow.Resources["ColumnContextMenu"] as ContextMenu;
//var rect = new Rectangle { Fill = Brushes.Gray };
//Grid.SetColumnSpan(rect, 10000);
//Children.Add(rect);
if (data.Count < 1)
{
return;
}
RowDefinitions.Add(new RowDefinition {
Height = GridLength.Auto
});
var columnCounter = 0;
foreach (var header in data[0])
{
ColumnDefinitions.Add(new ColumnDefinition {
});
var columnText = NewTextBox();
columnText.Background = new BrushConverter().ConvertFromString("#777") as Brush;
columnText.Tag = new TablePosition {
Column = columnCounter, Row = 0
};
columnText.ContextMenu = contextMenu;
var binding = new Binding("Text")
{
Source = header
};
columnText.SetBinding(TextBox.TextProperty, binding);
Grid.SetColumn(columnText, columnCounter);
Children.Add(columnText);
columnCounter++;
}
if (data.Count > 50)
{
mmApp.Model.Window.ShowStatusProgress("Binding table data...");
}
var rowCount = 1;
foreach (var row in data.Skip(1))
{
RowDefinitions.Add(new RowDefinition {
Height = GridLength.Auto
});
columnCounter = 0;
foreach (var column in row)
{
var columnText = NewTextBox();
columnText.Tag = new TablePosition {
Column = columnCounter, Row = rowCount
};
var binding = new Binding("Text")
{
Source = column, UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged, Mode = BindingMode.TwoWay
};
columnText.SetBinding(TextBox.TextProperty, binding);
//columnText.Text = column.Text;
columnText.ContextMenu = contextMenu;
Grid.SetColumn(columnText, columnCounter);
Grid.SetRow(columnText, rowCount);
Children.Add(columnText);
columnCounter++;
}
rowCount++;
if (rowCount % 8 == 0)
{
PreventRecursiveUpdates = false;
WindowUtilities.DoEvents();
PreventRecursiveUpdates = true;
}
}
var lastText = Children.OfType <TextBox>().LastOrDefault();
if (lastText != null)
{
lastText.PreviewKeyDown += (s, e) =>
{
if (e.Key == Key.Tab)
{
if (Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift))
{
return;
}
var newRow = new ObservableCollection <CellContent>();
foreach (var header in TableSource[0])
{
newRow.Add(new CellContent(string.Empty));
}
var textBox = s as TextBox;
var pos = textBox.Tag as TablePosition;
TableSource.Add(newRow);
SelectColumn(pos.Row + 1, 0);
}
};
}
PreventRecursiveUpdates = origRecursiveUpdates;
if (!PreventRecursiveUpdates)
{
InvalidateVisual();
}
}
private void RepopulateColumns()
{
Children.Clear();
ColumnDefinitions.Clear();
if (Columns == null)
{
return;
}
var columnCounter = -1;
var starColumnFound = false;
foreach (var column in Columns)
{
columnCounter++;
var gridColumn = new ColumnDefinition();
gridColumn.SetBinding(ColumnDefinition.WidthProperty, new Binding("ActualWidth")
{
Source = column, Mode = BindingMode.OneWay, Converter = new LengthToGridLengthConverter()
});
ColumnDefinitions.Add(new ColumnPanelColumnDefinition(gridColumn));
if (column.Width.GridUnitType == GridUnitType.Star)
{
starColumnFound = true;
}
if (column.ItemTemplate != null)
{
var content = column.ItemTemplate.LoadContent() as UIElement;
if (content == null)
{
continue;
}
Children.Add(content);
SetColumn(content, columnCounter);
}
else if (column.ColumnControl != ListColumnControls.Auto || (!column.BindingPath.StartsWith("Number") && !column.BindingPath.StartsWith("Image") && !column.BindingPath.StartsWith("Logo")))
{
var content = GetContentGridForColumn(column);
switch (column.ColumnControl)
{
case ListColumnControls.Auto:
case ListColumnControls.Text:
TextBlock text = null;
TextBox tb = null;
if (column.EditMode != ListRowEditMode.ReadWriteAll)
{
text = new TextBlock {
VerticalAlignment = VerticalAlignment.Center
};
SetEventCommands(text, column.ReadOnlyControlEventCommands);
SetHorizontalAlignment(text, column.CellContentAlignment);
text.SetBinding(TextBlock.TextProperty, new Binding(column.BindingPath));
if (!string.IsNullOrEmpty(column.ToolTipBindingPath))
{
text.SetBinding(ToolTipProperty, new Binding(column.ToolTipBindingPath));
}
else if (!string.IsNullOrEmpty(column.ToolTip))
{
text.ToolTip = column.ToolTip;
}
if (EditMode == ListRowEditMode.Manual && IsManualEditEnabled)
{
text.Visibility = Visibility.Collapsed;
}
if (column.CellForeground != null)
{
text.Foreground = column.CellForeground;
}
else if (!string.IsNullOrEmpty(column.CellForegroundBindingPath))
{
text.SetBinding(TextBlock.ForegroundProperty, new Binding(column.CellForegroundBindingPath));
}
content.Children.Add(text);
}
if (column.EditMode != ListRowEditMode.ReadOnly)
{
tb = new TextBox {
VerticalAlignment = VerticalAlignment.Stretch, HorizontalAlignment = HorizontalAlignment.Stretch, VerticalContentAlignment = VerticalAlignment.Center
};
SetEventCommands(tb, column.WriteControlEventCommands);
SetHorizontalContentAlignment(tb, column.CellContentAlignment, HorizontalAlignment.Stretch);
tb.SetBinding(TextBox.TextProperty, new Binding(string.IsNullOrEmpty(column.EditControlBindingPath) ? column.BindingPath : column.EditControlBindingPath)
{
UpdateSourceTrigger = column.EditControlUpdateSourceTrigger, StringFormat = column.EditControlStringFormat
});
if (!string.IsNullOrEmpty(column.ToolTipBindingPath))
{
tb.SetBinding(ToolTipProperty, new Binding(column.ToolTipBindingPath));
}
else if (!string.IsNullOrEmpty(column.ToolTip))
{
tb.ToolTip = column.ToolTip;
}
if (EditMode == ListRowEditMode.Manual && IsManualEditEnabled)
{
tb.Visibility = Visibility.Visible;
}
else if (column.EditMode == ListRowEditMode.ReadWriteAll)
{
tb.Visibility = Visibility.Visible;
}
else
{
tb.Visibility = Visibility.Collapsed;
}
if (column.EditTextBoxStyle != null)
{
tb.Style = column.EditTextBoxStyle;
}
else
{
tb.Padding = new Thickness(0);
tb.BorderThickness = new Thickness(0);
}
if (column.CellForeground != null)
{
tb.Foreground = column.CellForeground;
}
else if (!string.IsNullOrEmpty(column.CellForegroundBindingPath))
{
tb.SetBinding(Control.ForegroundProperty, new Binding(column.CellForegroundBindingPath));
}
content.Children.Add(tb);
}
if (column.EditMode == ListRowEditMode.Manual)
{
EditModeChanged += (s, e) =>
{
if (text != null)
{
text.Visibility = IsManualEditEnabled ? Visibility.Collapsed : Visibility.Visible;
}
if (tb != null)
{
tb.Visibility = IsManualEditEnabled ? Visibility.Visible : Visibility.Collapsed;
}
}
}
;
break;
case ListColumnControls.Checkmark:
var check = new CheckBox {
VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Right, Content = string.Empty, IsEnabled = false
};
SetEventCommands(check, column.ReadOnlyControlEventCommands);
check.SetBinding(ToggleButton.IsCheckedProperty, new Binding(string.IsNullOrEmpty(column.EditControlBindingPath) ? column.BindingPath : column.EditControlBindingPath)
{
UpdateSourceTrigger = column.EditControlUpdateSourceTrigger, StringFormat = column.EditControlStringFormat
});
if (!string.IsNullOrEmpty(column.ToolTipBindingPath))
{
check.SetBinding(ToolTipProperty, new Binding(column.ToolTipBindingPath));
}
else if (!string.IsNullOrEmpty(column.ToolTip))
{
check.ToolTip = column.ToolTip;
}
SetHorizontalAlignment(check, column.CellContentAlignment, HorizontalAlignment.Center);
if (column.EditCheckmarkStyle != null)
{
check.Style = column.EditCheckmarkStyle;
}
if (column.CellForeground != null)
{
check.Foreground = column.CellForeground;
}
else if (!string.IsNullOrEmpty(column.CellForegroundBindingPath))
{
check.SetBinding(Control.ForegroundProperty, new Binding(column.CellForegroundBindingPath));
}
content.Children.Add(check);
if (column.EditMode == ListRowEditMode.Manual)
{
var col2 = column;
EditModeChanged += (s, e) =>
{
if (check != null)
{
check.IsEnabled = IsManualEditEnabled;
SetEventCommands(check, check.IsEnabled ? col2.ReadOnlyControlEventCommands : col2.WriteControlEventCommands);
}
};
}
break;
case ListColumnControls.TextList:
TextBlock text2 = null;
ComboBox combo = null;
if (column.EditMode != ListRowEditMode.ReadWriteAll)
{
text2 = new TextBlock {
VerticalAlignment = VerticalAlignment.Center
};
SetEventCommands(text2, column.ReadOnlyControlEventCommands);
SetHorizontalAlignment(text2, column.CellContentAlignment);
if (!string.IsNullOrEmpty(column.ToolTipBindingPath))
{
text2.SetBinding(ToolTipProperty, new Binding(column.ToolTipBindingPath));
}
else if (!string.IsNullOrEmpty(column.ToolTip))
{
text2.ToolTip = column.ToolTip;
}
text2.SetBinding(TextBlock.TextProperty, new Binding(column.BindingPath));
if (EditMode == ListRowEditMode.Manual && IsManualEditEnabled)
{
text2.Visibility = Visibility.Collapsed;
}
if (column.CellForeground != null)
{
text2.Foreground = column.CellForeground;
}
else if (!string.IsNullOrEmpty(column.CellForegroundBindingPath))
{
text2.SetBinding(TextBlock.ForegroundProperty, new Binding(column.CellForegroundBindingPath));
}
content.Children.Add(text2);
}
if (column.EditMode != ListRowEditMode.ReadOnly)
{
combo = new ComboBox {
VerticalAlignment = VerticalAlignment.Stretch, HorizontalAlignment = HorizontalAlignment.Stretch, VerticalContentAlignment = VerticalAlignment.Center
};
SetEventCommands(combo, column.WriteControlEventCommands);
SetHorizontalContentAlignment(combo, column.CellContentAlignment, HorizontalAlignment.Stretch);
if (!string.IsNullOrEmpty(column.BindingPath) || !string.IsNullOrEmpty(column.EditControlBindingPath))
{
combo.SetBinding(Selector.SelectedValueProperty, new Binding(string.IsNullOrEmpty(column.EditControlBindingPath) ? column.BindingPath : column.EditControlBindingPath)
{
UpdateSourceTrigger = column.EditControlUpdateSourceTrigger, StringFormat = column.EditControlStringFormat
});
}
combo.SetBinding(ItemsControl.ItemsSourceProperty, new Binding(column.TextListItemsSourceBindingPath));
combo.SelectedValuePath = column.TextListSelectedValuePath;
combo.DisplayMemberPath = column.TextListDisplayMemberPath;
if (!string.IsNullOrEmpty(column.ToolTipBindingPath))
{
combo.SetBinding(ToolTipProperty, new Binding(column.ToolTipBindingPath));
}
else if (!string.IsNullOrEmpty(column.ToolTip))
{
combo.ToolTip = column.ToolTip;
}
if (EditMode == ListRowEditMode.Manual && IsManualEditEnabled)
{
combo.Visibility = Visibility.Visible;
}
else
{
combo.Visibility = Visibility.Collapsed;
}
if (column.EditTextListStyle != null)
{
combo.Style = column.EditTextListStyle;
}
else
{
combo.Padding = new Thickness(0);
combo.BorderThickness = new Thickness(0);
}
if (column.CellForeground != null)
{
combo.Foreground = column.CellForeground;
}
else if (!string.IsNullOrEmpty(column.CellForegroundBindingPath))
{
combo.SetBinding(Control.ForegroundProperty, new Binding(column.CellForegroundBindingPath));
}
content.Children.Add(combo);
}
if (column.EditMode == ListRowEditMode.Manual)
{
EditModeChanged += (s, e) =>
{
if (text2 != null)
{
text2.Visibility = IsManualEditEnabled ? Visibility.Collapsed : Visibility.Visible;
}
if (combo != null)
{
combo.Visibility = IsManualEditEnabled ? Visibility.Visible : Visibility.Collapsed;
}
}
}
;
break;
case ListColumnControls.Image:
var image = new Image {
VerticalAlignment = VerticalAlignment.Stretch, HorizontalAlignment = HorizontalAlignment.Stretch, Stretch = Stretch.UniformToFill
};
SetEventCommands(image, column.ReadOnlyControlEventCommands);
image.SetBinding(Image.SourceProperty, new Binding(column.BindingPath)
{
Mode = BindingMode.OneWay
});
if (!string.IsNullOrEmpty(column.ToolTipBindingPath))
{
image.SetBinding(ToolTipProperty, new Binding(column.ToolTipBindingPath));
}
else if (!string.IsNullOrEmpty(column.ToolTip))
{
image.ToolTip = column.ToolTip;
}
content.Children.Add(image);
break;
}
Children.Add(content);
SetColumn(content, columnCounter);
}
else if (column.BindingPath.StartsWith("Number"))
{
var content = GetContentGridForColumn(column);
var text = new TextBlock {
VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Right, TextAlignment = TextAlignment.Right
};
SetEventCommands(text, column.ReadOnlyControlEventCommands);
text.SetBinding(TextBlock.TextProperty, new Binding(column.BindingPath));
if (!string.IsNullOrEmpty(column.ToolTipBindingPath))
{
text.SetBinding(ToolTipProperty, new Binding(column.ToolTipBindingPath));
}
else if (!string.IsNullOrEmpty(column.ToolTip))
{
text.ToolTip = column.ToolTip;
}
if (column.CellForeground != null)
{
text.Foreground = column.CellForeground;
}
else if (!string.IsNullOrEmpty(column.CellForegroundBindingPath))
{
text.SetBinding(TextBlock.ForegroundProperty, new Binding(column.CellForegroundBindingPath));
}
content.Children.Add(text);
Children.Add(content);
SetColumn(content, columnCounter);
}
else if (column.BindingPath.StartsWith("Image") || column.BindingPath.StartsWith("Logo"))
{
var content = GetContentGridForColumn(column);
var image = new Rectangle
{
VerticalAlignment = VerticalAlignment.Stretch,
HorizontalAlignment = HorizontalAlignment.Stretch,
Height = double.NaN,
Width = double.NaN
};
SetEventCommands(image, column.ReadOnlyControlEventCommands);
image.SetBinding(Shape.FillProperty, new Binding(column.BindingPath));
if (!string.IsNullOrEmpty(column.ToolTipBindingPath))
{
image.SetBinding(ToolTipProperty, new Binding(column.ToolTipBindingPath));
}
else if (!string.IsNullOrEmpty(column.ToolTip))
{
image.ToolTip = column.ToolTip;
}
content.Children.Add(image);
Children.Add(content);
SetColumn(content, columnCounter);
}
}
if (starColumnFound)
{
var presenter = ElementHelper.FindVisualTreeParent <ContentPresenter>(this);
if (presenter != null)
{
presenter.HorizontalAlignment = HorizontalAlignment.Stretch;
}
}
}
