Esempio n. 1
0
 private void _tree_CellValueChanged(object sender, DevExpress.XtraTreeList.CellValueChangedEventArgs e)
 {
     if (!ReferenceEquals(CellValueChanged, null))
     {
         CellValueChanged.Invoke(sender, new CellValueChangedEventArgs(e));
     }
 }
        protected Task OnEditValueChanged <T>(T value)
        {
            //Console.WriteLine( $"value: {value}, {value?.GetType()}" );
            CellEditContext.CellValue = value;

            return(CellValueChanged.InvokeAsync(value));
        }
Esempio n. 3
0
 internal void fireCellValueChanged(TableCell cell)
 {
     if (CellValueChanged != null)
     {
         CellValueChanged.Invoke(cell, EventArgs.Empty);
     }
 }
Esempio n. 4
0
 private void _view_CellValueChanged(object sender, DevExpress.XtraGrid.Views.Base.CellValueChangedEventArgs e)
 {
     if (!ReferenceEquals(CellValueChanged, null))
     {
         CellValueChanged.Invoke(sender, new CellValueChangedEventArgs(e));
     }
 }
Esempio n. 5
0
        private void ViewChannel_ValueChanged(object sender, EventArgs e)
        {
            int index = ViewChannels.IndexOf(sender as ViewChannel);

            (dgDrawChannels.DataSource as BindingSource).ResetItem(index);

            CellValueChanged?.Invoke(this, new DataGridViewCellEventArgs(0, index));
        }
        /// <summary>
        /// Updated the internal cell values.
        /// </summary>
        /// <typeparam name="T">Type of the value being changed.</typeparam>
        /// <param name="value">Value that is updating.</param>
        /// <returns>A task that represents the asynchronous operation.</returns>
        protected Task OnEditValueChanged <T>(T value)
        {
            CellEditContext.CellValue = value;

            Column.SetValue(ValidationItem, value);

            return(CellValueChanged.InvokeAsync(value));
        }
Esempio n. 7
0
 private void GridViewCellValueChanged(object sender, CellValueChangedEventArgs e)
 {
     CellValueChanged?.Invoke(sender, e);
     if (_IsUpdateCurrentRowByCellValueChangedEvent)
     {
         MainView.UpdateCurrentRow();
     }
 }
Esempio n. 8
0
 protected override void Context()
 {
     _cellValueChanged          = new CellValueChanged();
     _cellValueChanged.ColumnId = "base";
     _cellValueChanged.RowIndex = 1;
     _cellValueChanged.OldValue = 2;
     _cellValueChanged.NewValue = 4f;
     base.Context();
 }
      protected override void Context()
      {
         base.Context();
         sut.EditObservedData(_dataRepository);
         _dto = new CellValueChangedDTO {ColumnIndex = 0, OldDisplayValue = 1, NewDisplayValue = 2, RowIndex = 3};
         _command = A.Fake<ICommand>();

         A.CallTo(() => _dim.UnitValueToBaseUnitValue(A<Unit>._, 1)).Returns(10);
         A.CallTo(() => _dim.UnitValueToBaseUnitValue(A<Unit>._, 2)).Returns(20);
         A.CallTo(() => _editObservedDataTask.SetValue(A<DataRepository>._, A<CellValueChanged>._))
            .Invokes(x => _cellValueChanged = x.GetArgument<CellValueChanged>(1)).Returns(_command);
      }
Esempio n. 10
0
 private void dgDrawChannels_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
 {
     if (e.ColumnIndex == 1)
     {
         colorDialog.Color = dgDrawChannels[1, e.RowIndex].Style.BackColor;
         if (colorDialog.ShowDialog() == DialogResult.OK)
         {
             ViewChannels[e.RowIndex].Color = colorDialog.Color;
             CellValueChanged?.Invoke(this, new DataGridViewCellEventArgs(e.ColumnIndex, e.RowIndex));
         }
     }
 }
        protected Task OnEditValueChanged <T>(T value)
        {
            CellEditContext.CellValue = value;

            return(CellValueChanged.InvokeAsync(value));
        }
Esempio n. 12
0
 /// <summary>
 /// 触发模板中值变化事件
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 public void OnCellValueChanged(object sender, Cell e)
 {
     CellValueChanged?.Invoke(sender, EventArgs.Empty);
 }
 public ICommand SetValue(DataRepository observedData, CellValueChanged cellValueChanged)
 {
     return(new SetObservedDataValueCommand(observedData, cellValueChanged).Run(_executionContext));
 }