/// <summary>
/// Sets the commands, column order and event handlers.
/// After this the VM is ready for operation
/// </summary>
/// <param name="column"></param>
private void InitializeColumn(ColumnDefinitionVM column)
{
int nonZeroOrderColumns = ColumnDefinitions.Count(c => c.ColumnOrder > 0);
if (column.ColumnOrder == 0)
{
column.ColumnOrder = nonZeroOrderColumns + 1;
}
column.RemoveCommand = new DelegateCommand((parameter) =>
{
int order = (int)parameter;
List <ColumnDefinitionVM> higherOrder = ColumnDefinitions.Where(cd => cd.ColumnOrder > order).ToList();
List <ColumnDefinitionVM> lowerOrder = ColumnDefinitions.Where(cd => cd.ColumnOrder < order).ToList();
foreach (ColumnDefinitionVM cdVM in higherOrder)
{
cdVM.ColumnOrder--;
}
ColumnDefinitions = lowerOrder.Concat(higherOrder).ToArray();
});
column.MoveLeft = MoveColumnLeft;
column.MoveRight = MoveColumnRight;
MoveColumnLeft.RaiseCanExecuteChanged();
MoveColumnRight.RaiseCanExecuteChanged();
}
protected override System.Windows.Size MeasureOverride(System.Windows.Size constraint)
{
//I assume Grid.MeasureOverride return the minimum size as desired size
Size MinimumDesiredSize = base.MeasureOverride(constraint);
//The remaining available space provided by the container
double ConstraintWidthRemaining = constraint.Width - MinimumDesiredSize.Width;
//The supposed remaining space if we assume than star columns width equals 0, will be calculated later
double WidthRemaining = ConstraintWidthRemaining;
//The width used in the remaining available space
double WidthUsed = 0;
//The number of column which are star sized
double StarSum = 0;
foreach (ColumnDefinition column in ColumnDefinitions.Where(c => c.Width.IsStar))
{
StarSum += column.Width.Value;
WidthRemaining += column.MinWidth;
}
foreach (ColumnDefinition column in ColumnDefinitions.Where(c => c.Width.IsStar))
{
double Ratio = column.Width.Value / StarSum;
double ColumnWidth = WidthRemaining * Ratio;
if (column.MaxWidth != 0.0)
{
if (ColumnWidth > column.MinWidth)
{
if (ColumnWidth <= column.MaxWidth)
{
WidthUsed += ColumnWidth - column.MinWidth;
}
else
{
WidthUsed += column.MaxWidth - column.MinWidth;
}
}
}
else
{
WidthUsed += ColumnWidth - column.MinWidth;
}
}
MinimumDesiredSize.Width += WidthUsed;
return(MinimumDesiredSize);
}
protected virtual void Initialize()
{
AddDepthCommand = new DelegateCommand(() =>
{
List <ColumnDefinitionVM> result = new List <ColumnDefinitionVM>(ColumnDefinitions);
ColumnDefinitionVM column = new DepthColumnDefinitionVM();
InitializeColumn(column);
result.Add(column);
ColumnDefinitions = result.ToArray();
});
AddLayerLengthCommand = new DelegateCommand(() =>
{
List <ColumnDefinitionVM> result = new List <ColumnDefinitionVM>(ColumnDefinitions);
ColumnDefinitionVM column = new LayerLengthColumnDefinitionVM();
InitializeColumn(column);
result.Add(column);
ColumnDefinitions = result.ToArray();
});
AddPhotoCommand = new DelegateCommand(() =>
{
List <ColumnDefinitionVM> result = new List <ColumnDefinitionVM>(ColumnDefinitions);
ColumnDefinitionVM column = new PhotoColumnDefinitionVM();
InitializeColumn(column);
result.Add(column);
ColumnDefinitions = result.ToArray();
});
AddLayerPropCommand = new DelegateCommand(() =>
{
List <ColumnDefinitionVM> result = new List <ColumnDefinitionVM>(ColumnDefinitions);
ColumnDefinitionVM column = new LayeredTextColumnDefinitionVM(layersTemplateSource);
InitializeColumn(column);
result.Add(column);
ColumnDefinitions = result.ToArray();
});
AddLayerBoundsCommand = new DelegateCommand(() => {
List <ColumnDefinitionVM> result = new List <ColumnDefinitionVM>(ColumnDefinitions);
ColumnDefinitionVM column = new LayerEditColumnDefinitionVM(layerRankNameSource);
InitializeColumn(column);
result.Add(column);
ColumnDefinitions = result.ToArray();
});
AddLayerSamplesCommand = new DelegateCommand(() => {
List <ColumnDefinitionVM> result = new List <ColumnDefinitionVM>(ColumnDefinitions);
ColumnDefinitionVM column = new LayerSamplesDefinitionVM();
InitializeColumn(column);
result.Add(column);
ColumnDefinitions = result.ToArray();
});
AddVisualCommand = new DelegateCommand(() => {
List <ColumnDefinitionVM> result = new List <ColumnDefinitionVM>(ColumnDefinitions);
ColumnDefinitionVM column = new VisualColumnDefinitionVM(layersTemplateSource);
InitializeColumn(column);
result.Add(column);
ColumnDefinitions = result.ToArray();
});
AddIconsCommand = new DelegateCommand(() => {
List <ColumnDefinitionVM> result = new List <ColumnDefinitionVM>(ColumnDefinitions);
ColumnDefinitionVM column = new IconsColumnDefinitionVM(layersTemplateSource);
InitializeColumn(column);
result.Add(column);
ColumnDefinitions = result.ToArray();
});
MoveColumnLeft = new DelegateCommand((parameter) =>
{
int order = (int)parameter;
ColumnDefinitionVM target = ColumnDefinitions.Where(cd => cd.ColumnOrder == order).Single();
ColumnDefinitionVM toSwap = ColumnDefinitions.Where(cd => cd.ColumnOrder == order - 1).Single();
target.ColumnOrder = order - 1;
toSwap.ColumnOrder = order;
RaisePropertyChanged(nameof(ColumnDefinitions));
RaisePropertyChanged(nameof(OrderedColumnDefinitions));
MoveColumnLeft.RaiseCanExecuteChanged();
MoveColumnRight.RaiseCanExecuteChanged();
}, (parameter) =>
{
if (parameter != null)
{
int order = (int)parameter;
if (order > 1)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
});
MoveColumnRight = new DelegateCommand((parameter) =>
{
int order = (int)parameter;
ColumnDefinitionVM target = ColumnDefinitions.Where(cd => cd.ColumnOrder == order).Single();
ColumnDefinitionVM toSwap = ColumnDefinitions.Where(cd => cd.ColumnOrder == order + 1).Single();
target.ColumnOrder = order + 1;
toSwap.ColumnOrder = order;
RaisePropertyChanged(nameof(ColumnDefinitions));
RaisePropertyChanged(nameof(OrderedColumnDefinitions));
MoveColumnLeft.RaiseCanExecuteChanged();
MoveColumnRight.RaiseCanExecuteChanged();
}, (parameter) =>
{
if (parameter != null)
{
int order = (int)parameter;
if (order < ColumnDefinitions.Length)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
});
ImportFromFileCommnad = new DelegateCommand(() =>
{
ColumnDefinitionVM[] settings;
if (colSettingPersistence.Load(out settings))
{
ColumnDefinitions = settings;
foreach (var col in ColumnDefinitions)
{
InitializeColumn(col);
}
}
});
ExportToFileCommand = new DelegateCommand(() => {
colSettingPersistence.Persist(OrderedColumnDefinitions);
});
}
/// <summary>
/// Delete compoenent from the rung
/// </summary>
/// <param name="component">Component to be deleted</param>
public RungUI Remove(ComponentUIBase component)
{
ComponentGridPosition _component = _Components.Where(x => x.Component == component).First();
if (_LogicalRung.Components.Where(x => x.LeftLide == component.LogicComponent.LeftLide && x.RightLide == component.LogicComponent.RightLide).Count() > 1)
{
foreach (ComponentGridPosition item in GetAllBetween(component.LogicComponent.LeftLide, component.LogicComponent.RightLide).Where(x => x.Row > _component.Row))
{
item.SetPossition(item.Row - 1, item.Column);
}
}
else
{
IEnumerable <ComponentGridPosition> RR = _Components.Where(x => x.Component.LogicComponent.RightLide == component.LogicComponent.RightLide && x != _component);
if (RR.Count() > 0)
{
IEnumerable <ComponentGridPosition> column_components = _Components.Where(x => x.Column == _component.Column);
if (column_components.Count() == 1)
{
foreach (ComponentGridPosition item in _Components.Where(x => x.Column > _component.Column))
{
item.SetPossition(item.Row, item.Column - 1);
}
}
else
{
foreach (ComponentGridPosition item in GetAllBetween(component.LogicComponent.LeftLide, component.LogicComponent.RightLide).Where(x => x.Row > _component.Row))
{
item.SetPossition(item.Row - 1, item.Column);
}
}
}
else
{
foreach (ComponentGridPosition item in _Components.Where(x => x.Component.LogicComponent.LeftLide == component.LogicComponent.RightLide))
{
item.SetPossition(item.Row, item.Column - 1);
}
}
}
_Components.Remove(_component);
_LogicalRung.Remove(component.LogicComponent);
Children.Remove(component);
var row = RowDefinitions.Where(x => _Components.Where(y => (y.Row == RowDefinitions.IndexOf(x))).Count() == 0);
if (row.Count() != 0)
{
int row_index = RowDefinitions.IndexOf(row.First());
foreach (ComponentGridPosition item in _Components.Where(x => x.Row > row_index))
{
item.SetPossition(item.Row - 1, item.Column);
}
RowDefinitions.RemoveAt(row_index);
}
var column = ColumnDefinitions.Where(x => _Components.Where(y => (y.Column == ColumnDefinitions.IndexOf(x))).Count() == 0);
if (column.Count() != 0)
{
int column_index = ColumnDefinitions.IndexOf(column.First());
if (_component.Column >= ColumnDefinitions.Count - _OutputBlockLegth)
{
_OutputBlockLegth--;
}
foreach (ComponentGridPosition item in _Components.Where(x => x.Column > column_index))
{
item.SetPossition(item.Row, item.Column - 1);
}
ColumnDefinitions.RemoveAt(column_index);
}
return(this);
}
public virtual void EndInit()
{
//==============================================
// 创建过滤条件
//==============================================
AllFilters = new List <FilterControlBase>();
foreach (FilterDefinition fd in FilterDefinitions)
{
FilterControlBase fc = (FilterControlBase)Activator.CreateInstance(fd.FilterControlType, true);
fc.DataPropertyName = fd.DataPropertyName;
fc.Title = fd.Title;
if (!fd.FilterOperator.IsNullOrWhiteSpace())
{
fc.FilterOperator = fd.FilterOperator;
}
fc.Parent = pFilters;
AllFilters.Add(fc);
}
//==============================================
// 创建表格
//==============================================
//空白组默认设置为页面标题
ColumnDefinitions.ForEach(c => { if (c.GroupName.IsNullOrWhiteSpace())
{
c.GroupName = Text;
}
});
//创建Tab页
tabContainer.TabPages.Clear();
var queryGroups = ColumnDefinitions.Select(c => c.GroupName).Distinct().ToArray();
foreach (string g in queryGroups)
{
tabContainer.TabPages.Add(g);
//创建表格
GridViewer dgv = new GridViewer();
//添加列
foreach (var col in ColumnDefinitions.Where(c => c.GroupName == g))
{
dgv.CreateColumn(col.ColumnType, col.Title, col.DataPropertyName, col.Name, col.Width, col.SortMode, col.SortOrder, col.Visible, col.Index, col.Frozen);
}
dgv.Dock = DockStyle.Fill;
dgv.Parent = tabContainer.TabPages[tabContainer.TabCount - 1];
//TODO: 暂不支持排序
}
//只有一个表格则不显示TabControl
if (tabContainer.TabPages.Count == 1)
{
Control dgv = tabContainer.TabPages[0].Controls[0];
dgv.Parent = this;
Controls.Remove(tabContainer);
tabContainer = null; //dispose
dgv.BringToFront();
}
//所有表格
AllGridView = this.FindChildControl(c => c is DataGridView).OfType <DataGridView>().ToList();
//==============================================
// 生成Select语句
//==============================================
var query = from dgv in AllGridView
from col in dgv.Columns.OfType <DataGridViewColumn>()
where !col.DataPropertyName.IsNullOrWhiteSpace()
select col.DataPropertyName;
List <string> fields = new List <string>();
foreach (string col in query.Distinct())
{
fields.Add("[{0}] AS '{1}'".FormatWith(col.Replace(".", "].["), col));
}
Sentence_Select = string.Join(", ", fields.ToArray());
//==============================================
// 关联表格的选择及滚动
//==============================================
if (AllGridView.Count > 1)
{
DataGridView dgv = AllGridView[0];
for (int i = 1; i < AllGridView.Count; i++)
{
DataGridView tmp = AllGridView[i];
dgv.SyncSelectedRowIndex(tmp);
dgv.SyncRowHeight(tmp);
dgv.SyncVerticalScroll(tmp);
}
}
//==============================================
// 注册表格事件
//==============================================
//注册事件
AllGridView.ForEach(d =>
{
d.ColumnHeaderMouseClick += ColumnHeaderMouseClick;
d.SelectionChanged += SelectionChanged;
d.CellDoubleClick += CellDoubleClick;
});
}
// Do measurement when in horizontal orientation
private void MeasureHorizontal(nfloat parentWidth, nfloat parentHeight)
{
// Work out our height
nfloat layoutWidth = LayoutParameters.TryResolveWidth(this, parentWidth, parentHeight);
nfloat layoutHeight = LayoutParameters.TryResolveHeight(this, parentWidth, parentHeight);
// Work out the total fixed size
var paddings = Padding.TotalWidth();
_goneViews = new List <View>();
_arrangedViews = new View[RowDefinitions.Count, ColumnDefinitions.Count];
var columnWidthFillParentSubviews = new List <View>();
//calculating columns
var minWidth = (nfloat)ColumnDefinitions.Sum(x => x.MinWidth);
foreach (var v in SubViews.Where(x => !x.Gone))
{
_arrangedViews[v.Row, v.Column] = v;
var columnDefinition = ColumnDefinitions[v.Column];
var rowDefinition = RowDefinitions[v.Column];
nfloat width;
if (columnDefinition.Width > 0)
{
width = columnDefinition.Width;
}
else if (columnDefinition.MaxWidth > 0)
{
width = columnDefinition.MaxWidth;
}
else
{
width = parentWidth - paddings;
}
nfloat height;
if (rowDefinition.Height > 0)
{
height = rowDefinition.Height;
}
else
{
height = adjustLayoutHeight(layoutHeight, v);
}
if (v.LayoutParameters.WidthUnits != Units.ParentRatio)
{
v.Measure(width - v.LayoutParameters.Margins.TotalWidth(), height);
}
else
{
v._measuredSize = new CGSize(0, 0);
v._measuredSizeValid = true;
columnWidthFillParentSubviews.Add(v);
}
}
{
nfloat totalWeight = 0;
nfloat totalWidth = 0;
var columnId = -1;
foreach (var column in ColumnDefinitions)
{
columnId++;
column.CalculatedWidth = 0;
if (column.Width > 0)
{
column.CalculatedWidth = column.Width;
}
else if (column.Width == AutoSize.WrapContent)
{
for (int rowId = 0; rowId < RowDefinitions.Count; rowId++)
{
var v = _arrangedViews[rowId, columnId];
if (v != null)
{
column.CalculatedWidth = NMath.Max(column.CalculatedWidth, v.GetMeasuredSize().Width + v.LayoutParameters.Margins.TotalWidth());
}
}
}
else if (column.Width == AutoSize.FillParent)
{
totalWeight += column.Weight;
}
totalWidth += column.CalculatedWidth;
}
var room = layoutWidth - totalWidth;
foreach (var column in ColumnDefinitions.Where(x => x.Width == AutoSize.FillParent))
{
columnId++;
column.CalculatedWidth = room * column.Weight / totalWeight;
}
}
{
var totalWeight = 0;
var totalHeight = 0;
var rowId = -1;
foreach (var row in RowDefinitions)
{
rowId++;
if (row.Height > 0)
{
row.CalculatedHeight = row.Height;
continue;
}
if (row.Height == AutoSize.WrapContent)
{
row.CalculatedHeight = 0;
for (int columnId = 0; columnId < ColumnDefinitions.Count; columnId++)
{
var v = _arrangedViews[rowId, columnId];
if (v != null)
{
row.CalculatedHeight = NMath.Max(row.CalculatedHeight, v.GetMeasuredSize().Height);
}
}
}
}
var room = layoutHeight - totalHeight;
foreach (var row in RowDefinitions.Where(x => x.Height == AutoSize.FillParent))
{
row.CalculatedHeight = room * row.Weight / totalWeight;
}
}
CGSize sizeMeasured = CGSize.Empty;
foreach (var item in ColumnDefinitions)
{
sizeMeasured.Width += item.CalculatedWidth;
}
sizeMeasured.Width += ColSpacing * (ColumnDefinitions.Count - 1);
foreach (var item in RowDefinitions)
{
sizeMeasured.Height += item.CalculatedHeight;
}
sizeMeasured.Height += RowSpacing * (RowDefinitions.Count - 1);
foreach (var v in columnWidthFillParentSubviews)
{
v.Measure(ColumnDefinitions[v.Column].CalculatedWidth, RowDefinitions[v.Row].CalculatedHeight);
}
// And finally, set our measure dimensions
SetMeasuredSize(LayoutParameters.ResolveSize(new CGSize(layoutWidth, layoutHeight), sizeMeasured));
}
