/// <summary>
///
/// </summary>
/// <param name="field"></param>
/// <param name="indexInRecordView"></param>
internal override void MapFieldDefinition(IFieldView field, int indexInRecordView)
{
base.MapFieldDefinition(field, indexInRecordView);
//add ranges of the field
ViewBoundaries.AddFieldBoundaries(field, fieldIndexInViewByIndexInRecord[indexInRecordView]);
}
/// <summary>
/// return view that own this field
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
RuntimeViewBase GetView(IFieldView field)
{
RuntimeViewBase view = null;
if (field.IsVirtual)
{
view = VirtualView;
}
else
{
int linkId = field.DataviewHeaderId;
if (ViewMain != null && ((IDataviewHeader)ViewMain.DataSourceViewDefinition).Id == linkId)
{
view = ViewMain;
}
else if (LinkViews.ContainsKey(linkId))
{
view = LinkViews[linkId];
}
else
{
view = RemoteRuntimeView;
}
}
return(view);
}
/// <summary>
///
/// </summary>
/// <param name="fieldView"></param>
/// <param name="userRange"></param>
/// <returns></returns>
private UnitComputeResult CheckUserRange(IFieldView fieldView, UserRange userRange)
{
UnitComputeResult result = new UnitComputeResult();
string fieldValue = fieldView.ValueFromCurrentRecord.Trim();
switch (fieldView.StorageAttribute)
{
case StorageAttribute.NUMERIC:
case StorageAttribute.DATE:
case StorageAttribute.TIME:
{
int fieldValueInt = new NUM_TYPE(fieldValue).NUM_2_LONG();
// check the min value
if (!userRange.nullMin && !userRange.discardMin)
{
int min = new NUM_TYPE(userRange.min).NUM_2_LONG();
if (fieldValueInt < min)
{
result.ErrorCode = UnitComputeErrorCode.RangeFailed;
}
}
// check the max value
if (result.Success && !userRange.nullMax && !userRange.discardMax)
{
int max = new NUM_TYPE(userRange.max).NUM_2_LONG();
if (fieldValueInt > max)
{
result.ErrorCode = UnitComputeErrorCode.RangeFailed;
}
}
}
break;
default:
{
// check the min value
if (!userRange.nullMin && !userRange.discardMin)
{
if (String.Compare(fieldValue, (string)userRange.min, StringComparison.Ordinal) < 0)
{
result.ErrorCode = UnitComputeErrorCode.RangeFailed;
}
}
// check the max value
if (result.Success && !userRange.nullMax && !userRange.discardMax)
{
if (String.Compare(fieldValue, (string)userRange.max, StringComparison.Ordinal) > 0)
{
result.ErrorCode = UnitComputeErrorCode.RangeFailed;
}
}
}
break;
}
return(result);
}
private void TryDisposeFieldView()
{
if (View != null && View is IDisposable disposable)
{
disposable.Dispose();
View = null;
}
}
/// <summary>
/// map field definitions
/// </summary>
/// <param name="field"></param>
/// <param name="indexInRecordView"></param>
internal virtual void MapFieldDefinition(IFieldView field, int indexInRecordView)
{
//map index in view to index in record and backwards
int indexInView = currentValues.Add(new FieldValue());
fieldIndexInRecordByIndexInView[indexInView] = indexInRecordView;
fieldIndexInViewByIndexInRecord[indexInRecordView] = indexInView;
}
public override void Given()
{
view = Moq.Stub <IFieldView>();
field = Moq.Stub <IField_v2>();
field.SetupGet(x => x.Label).Returns("aaaa");
field.SetupGet(x => x.Value).Returns("bbbb");
field.SetupGet(x => x.ObservableValue).Returns(Moq.Stub <IObservable <object> >());
}
public override void Given()
{
view = Moq.Stub<IFieldView>();
field = Moq.Stub<IField_v2>();
field.SetupGet(x => x.Label).Returns("aaaa");
field.SetupGet(x => x.Value).Returns("bbbb");
field.SetupGet(x => x.ObservableValue).Returns(Moq.Stub<IObservable<object>>());
}
/// <summary>
/// map all fields to the views they belong to
/// </summary>
internal void MapRecordFields()
{
for (int i = 0; i < Fields.Count; i++)
{
IFieldView field = Fields[i];
RuntimeViewBase view = GetView(field);
view.MapFieldDefinition(field, i);
}
}
protected ComputeFieldStrategy CreateComputeFieldStrategy(IFieldView field, bool checkLocate)
{
return(new ComputeFieldStrategy()
{
Field = field,
CheckLocate = checkLocate,
ShouldComputeOnFetch = field.IsVirtual && !field.AsReal && field.HasInitExpression
});
}
public GameManager(IFieldView fieldView, IConsoleInput consoleInput, IBuilder builder, IRandom random, IBorderChecker borderChecker, IEmptyCellProvider emptyCellProvider)
{
_consoleInput = consoleInput;
_builder = builder;
_fieldView = fieldView;
_random = random;
_borderChecker = borderChecker;
_emptyCellProvider = emptyCellProvider;
}
public void Setup(int fieldWidth, int fieldHeight)
{
_field = _builder.GetFieldOfAnimals(fieldWidth, fieldHeight);
_fieldView = _builder.GetFieldView(_field);
_keyPressStrategy.Add(
ConsoleKey.A, AddAnimalToRandomPosition <Antelope>);
_keyPressStrategy.Add(
ConsoleKey.L, AddAnimalToRandomPosition <Lion>);
}
protected override void RenderInternal(IRenderContext context)
{
GridContainer grid = new GridContainer(modelDefinition);
context.Add(grid);
List <(int column, int row, int with, int height, IFieldDefinition definition)> fieldPositions = new List <(int column, int row, int with, int height, IFieldDefinition definition)>();
foreach (IFieldDefinition fieldDefinition in modelDefinition.Fields)
{
int column = fieldDefinition.Metadata.GetGridColumn(0);
int row = fieldDefinition.Metadata.GetGridRow(0);
fieldPositions.Add((column, row, 0, 0, fieldDefinition));
}
int columns = fieldPositions.Select(f => f.column).Max() + 1;
int rows = fieldPositions.Select(f => f.row).Max() + 1;
for (int i = 0; i < columns; i++)
{
grid.ColumnDefinitions.Add(new ColumnDefinition());
}
for (int i = 0; i < rows; i++)
{
grid.RowDefinitions.Add(new RowDefinition()
{
Height = new GridLength(0, GridUnitType.Auto)
});
}
foreach (var fieldPosition in fieldPositions)
{
GridNode node = new GridNode(fieldPosition.definition);
grid.Children.Add(node);
node.Column = fieldPosition.column;
node.Row = fieldPosition.row;
if (fieldPosition.definition.Metadata.TryGetGridColumnSpan(out int columnSpan))
{
node.ColumnSpan = columnSpan;
}
if (fieldPosition.definition.Metadata.TryGetGridRowSpan(out int rowSpan))
{
node.RowSpan = rowSpan;
}
IFieldView <IRenderContext> fieldView = fieldViewProvider.Get(modelDefinition, fieldPosition.definition);
AddFieldView(fieldPosition.definition.Identifier, fieldView);
node.FieldView = fieldView;
}
}
/// <summary>
/// Get the "range" boundary definition of the field
/// </summary>
/// <param name="Field"></param>
/// <param name="indexInView"></param>
/// <returns></returns>
internal FieldBoundaries GetFieldRange(IFieldView Field, int indexInView)
{
FieldBoundaries boundary = null;
if (Field.Range != null)
{
boundary = GetFieldBoundary(Field, indexInView);
boundary.Range = Field.Range;
}
return(boundary);
}
/// <summary>
/// Get the "locate" boundary definition of the field
/// </summary>
/// <param name="Field"></param>
/// <param name="indexInView"></param>
/// <returns></returns>
internal FieldBoundaries GetFieldLocate(IFieldView Field, int indexInView)
{
FieldBoundaries boundary = null;
if (Field.Locate != null)
{
boundary = GetFieldBoundary(Field, indexInView);
boundary.Locate = Field.Locate;
}
return(boundary);
}
/// <summary>
/// convert a UserRange object to A RangeData object
/// </summary>
/// <param name="userRange"></param>
/// <param name="field"></param>
/// <returns></returns>
internal RangeData UserRangeToDataRange(UserRange userRange, IFieldView fieldView)
{
RangeData rangedata = new RangeData();
rangedata.FieldIndex = TaskViews.ViewMain.GetFieldIndexInViewByIndexInRecord(fieldView.Id);
InitBoundary(rangedata.Min, fieldView.StorageAttribute, userRange.discardMin, userRange.min, fieldView.Length, Char.MinValue);
InitBoundary(rangedata.Max, fieldView.StorageAttribute, userRange.discardMax, userRange.max, fieldView.Length, Char.MaxValue);
return(rangedata);
}
public MainForm()
{
InitializeComponent();
_field = new Field(10, 10, 10);
_inputManager = new InputManager(_field, this);
_fieldView = new ControlFieldView(_field,
new ControlViewAdapter(this), _inputManager);
_soundPlayer = new WaveSoundPlayer(_field);
_stopwatch = new StdStopwatch();
_field.Modified += FieldModified;
}
/// <summary>
/// link has locate
/// </summary>
/// <param name="dataviewHeaderId"></param>
/// <returns></returns>
internal bool LinkHasLocate(int dataviewHeaderId)
{
foreach (var indexInRecord in this.fieldIndexInRecordByIndexInView.Values)
{
IFieldView fieldView = LocalDataviewManager.TaskViews.Fields[indexInRecord];
if (fieldView.Id == dataviewHeaderId && fieldView.Locate != null) //check dataviewHeaderId!!!
{
return(true);
}
}
return(false);
}
public FieldPresenter(IFieldView fieldView, IGame game, IMessageHub aggregator)
{
_game = game;
_fieldView = fieldView;
_fieldView.CellClick += OnCellClick;
_fieldView.FieldMouseDown += OnFieldMouseDown;
_fieldView.RenderField(_game.Minefield);
_aggregator = aggregator;
_aggregator.Subscribe <GameStartedMessage>(m => OnGameStarted(m.Game));
}
private void OnChanged(IFieldDefinition definition)
{
TryDisposeFieldView();
Definition = definition;
TryRegisterSelf();
if (VisualTree.TryGetFieldViewProvider(this, out IFieldViewProvider <IRenderContext> viewProvider) && VisualTree.TryGetModelDefinition(this, out IModelDefinition modelDefinition))
{
View = viewProvider.Get(modelDefinition, definition);
View.Render(new ContentControlRenderContext(this));
}
}
/// <summary>
/// CTOR
/// </summary>
/// <param name="dataviewSynchronizer"></param>
/// <param name="recordComputer"></param>
/// <param name="fieldView"></param>
/// <param name="value"></param>
public IncrementalLocateComputeStrategy(IFieldView fieldView, string minValue)
{
Debug.Assert(fieldView.IsVirtual || fieldView.IsLink);
this.fieldView = fieldView;
switch (fieldView.StorageAttribute)
{
case StorageAttribute.ALPHA:
case StorageAttribute.UNICODE:
case StorageAttribute.NUMERIC:
this.minValue = minValue;
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="recordComputer"></param>
/// <param name="field"></param>
private void AddComputeFieldStrategy(RecordComputer recordComputer, IFieldView field)
{
bool checkLocate = ShouldCheckLocateOnField(field);
if (field.IsLink)
{
RecomputeId ownerLinkComputeId = RecomputeIdFactory.GetDataviewHeaderComputeId(field.DataviewHeaderId);
var ownerLinkComputer = linkComputers[ownerLinkComputeId];
ownerLinkComputer.Add(CreateComputeFieldStrategy(field, checkLocate));
}
else
{
recordComputer.Add(CreateComputeFieldStrategy(field, checkLocate));
}
}
/// <summary>
/// This will add the user locates so that view refresh will use this locates value to perform locate.
/// </summary>
/// <returns></returns>
internal override ReturnResultBase Execute()
{
IFieldView fieldView = TaskViews.Fields[fieldIndex];
if (fieldView.IsVirtual || fieldView.IsLink)
{
LocalDataviewManager.UserLocates.Add(userRange);
}
else
{
LocalDataviewManager.UserGatewayLocates.Add(UserRangeToDataRange(userRange, fieldView));
}
return(new ReturnResult());
}
protected override void RenderInternal(IRenderContext context)
{
StackContainer panel = new StackContainer(modelDefinition);
context.Add(panel);
foreach (IFieldDefinition fieldDefinition in modelDefinition.Fields)
{
StackNode node = new StackNode(fieldDefinition);
panel.Children.Add(node);
IFieldView <IRenderContext> fieldView = fieldViewProvider.Get(modelDefinition, fieldDefinition);
AddFieldView(fieldDefinition.Identifier, fieldView);
node.FieldView = fieldView;
}
}
/// <summary>
///
/// </summary>
/// <param name="Field"></param>
/// <param name="indexInView"></param>
/// <returns></returns>
private FieldBoundaries GetFieldBoundary(IFieldView Field, int indexInView)
{
FieldBoundaries boundary = new FieldBoundaries();
RuntimeReadOnlyView runtimeRealView = RuntimeViewBase as RuntimeReadOnlyView;
boundary.IndexInView = indexInView;
boundary.IsLink = Field.IsLink;
boundary.StorageAttribute = Field.StorageAttribute;
if (runtimeRealView != null)
{
boundary.DBField = runtimeRealView.GetDbField(boundary.IndexInView);
}
return(boundary);
}
/// <summary>
/// add field's ranges to the collection
/// </summary>
/// <param name="field"></param>
/// <param name="indexInView"></param>
internal void AddFieldBoundaries(IFieldView field, int indexInView)
{
FieldBoundaries fieldBoundaries = GetFieldRange(field, indexInView);
if (fieldBoundaries != null)
{
runtimeBoundaries.Add(fieldBoundaries);
}
fieldBoundaries = GetFieldLocate(field, indexInView);
if (fieldBoundaries != null)
{
runtimeBoundaries.Add(fieldBoundaries);
HasLocate = true;
}
}
public FieldPresenter(IFieldView view, MasterPresenter mp)
{
this.composer = new HeightmapComposer(new VisualLogger());
composer.ErosionStarted += Composer_ErosionStarted;
composer.LayerDescribed += Composer_LayerDescribed;
composer.MergeStarted += Composer_MergeStarted;
composer.LayerGenerated += Composer_LayerGenerated;
composer.RiverGenerationStarted += Composer_RiverGenerationStarted;
ParentPresenter = mp;
_uiScheduler = TaskScheduler.FromCurrentSynchronizationContext();
FieldView = view;
zoomManager = new ZoomManager(view);
zoomManager.ZoomChanged += ZoomManager_ZoomChanged;
setupDataSources();
setupFieldDefaults(BaseField);
updateBasePoly();
}
/// <summary>
///
/// </summary>
/// <returns></returns>
internal override ReturnResultBase Execute()
{
IRangeDataBuilder origRangeDataBuilder = null;
IFieldView fieldView = TaskViews.Fields[fieldId];
// Initialize the stuff needed to locate the right record
if (!fieldView.IsVirtual && !fieldView.IsLink)
{
// set the range builder, which will pass the data to the gateway
origRangeDataBuilder = TaskViews.ViewMain.RangeBuilder;
TaskViews.ViewMain.RangeBuilder = new IncrementalLocateRangeDataBuilder(TaskViews.ViewMain.ViewBoundaries, minValue, fieldView);
// use the base record computer - no need for extra computing after the fetch
recordComputer = base.RecordComputer;
}
else
{
// the gateway will not compute it for us - need to use a special record computer
RecordComputerBuilder recordComputerBuilder = new IncrementalLocateRecordComputerBuilder(fieldView, minValue)
{
LocalDataviewManager = LocalDataviewManager,
TaskViews = TaskViews
};
recordComputer = recordComputerBuilder.Build();
}
TaskViews.ViewMain.CurrentCursor = TaskViews.ViewMain.LocateCursor;
// try and get a matching record
base.Execute();
TaskViews.ViewMain.CurrentCursor = TaskViews.ViewMain.defaultCursor;
// restore ViewMain state
if (origRangeDataBuilder != null)
{
TaskViews.ViewMain.RangeBuilder = origRangeDataBuilder;
}
return(new GatewayResult());
}
/// <summary>
/// Check if field is sortable or Not
/// </summary>
/// <param name="indexInView"> Index of field Of which need to check the sortable condition</param>
/// <returns></returns>
private bool IsFieldSortable(int indexInView)
{
bool isFieldSortable = true;
IFieldView field = mainView.LocalDataviewManager.TaskViews.Fields[indexInView - 1];
// Sort segment should be added only if fld is real and from Main Data Sourcei.e. MainView.
if (!field.IsVirtual && field.DataviewHeaderId == RuntimeViewBase.MAIN_VIEW_ID)
{
int realFldIdx = mainView.GetFieldIndexInViewByIndexInRecord(indexInView - 1);
DBField dbTimeField = mainView.GetDbField(realFldIdx);
if (dbTimeField.Attr == (char)StorageAttributeType.Time && dbTimeField.PartOfDateTime > 0)
{
//If sort is applied only on time field of date time pair then sort is not allowed to time field.
isFieldSortable = false;
//If sort is applied on date and time field of date time pair then sort is not allowed to time field.
for (int i = 0; i < RuntimeSorts.getSize(); i++)
{
Sort sort = RuntimeSorts.getSort(i);
int dateIndex = mainView.GetFieldIndexInViewByIndexInRecord(sort.fldIdx - 1);
DBField dbDateField = mainView.GetDbField(dateIndex);
if (dbDateField.Isn == dbTimeField.PartOfDateTime)
{
isFieldSortable = true;
break;
}
}
}
}
else
{
isFieldSortable = false;
}
return(isFieldSortable);
}
public FieldController(FieldConfig config, IFieldView view)
{
var _fieldModel = new FieldModel(config);
foreach (var nodeConfig in config._field)
{
Node node = null;
switch (nodeConfig.CellType)
{
case FieldConfigEnum.Floor:
node = view.CreatePassableNode(new Vector3(nodeConfig.X, 0, nodeConfig.Y));
break;
case FieldConfigEnum.Spawn:
node = view.SpawnPlayer(new Vector3(nodeConfig.X, 0, nodeConfig.Y));
break;
case FieldConfigEnum.Wall:
node = view.CreateImpassableNode(new Vector3(nodeConfig.X, 0, nodeConfig.Y));
break;
case FieldConfigEnum.Exit:
node = view.CreateExit(new Vector3(nodeConfig.X, 0, nodeConfig.Y));
break;
default:
Debug.LogError("invalid node type");
break;
}
node.Point.X = nodeConfig.X;
node.Point.Z = nodeConfig.Y;
_fieldModel.SetNode(node);
}
FieldStorage.UpdateField(_fieldModel);
}
public FieldController(IFieldView fieldView, IGame game)
{
_fieldView = fieldView;
_game = game;
}
protected FieldViewModelBase(IFieldView view, IField_v2 field)
{
_view = view;
_field = field;
_field.ObservableValue.Subscribe(_ => this.Property(x => x.Value));
}
public TestableFieldViewModelBase(IFieldView view, IField_v2 field)
: base(view, field)
{
}
protected FieldViewModelBase(IFieldView view, IField_v2 field)
{
_view = view;
_field = field;
_field.ObservableValue.Subscribe(_ => this.Property(x => x.Value));
}
public Form1()
{
InitializeComponent();
Field = new ChessFieldView(new PointF(20.0f, 20.0f), new PointF(Width - 60.0f, Height - 80.0f));
}
