private void RefreshCaptions()
{
PropertyChanged.Notify(this, nameof(PageHeader),
nameof(GeneralProceedingParagraphHeader),
nameof(GeneralProceedingItem1),
nameof(GeneralProceedingItem2),
nameof(GeneralProceedingItem3),
nameof(GeneralProceedingItem4),
nameof(GeneralProceedingItem5),
nameof(ImportantClassesParagraphHeader),
nameof(ImportantClassesParagraphNote),
nameof(FieldCoordinateParagraphHeader),
nameof(FieldCoordinateParagraphText),
nameof(PlayerAndStateParagraphHeader),
nameof(PlayerAndStateParagraphText),
nameof(WallParagraphHeader),
nameof(WallParagraphText),
nameof(BoardStateParagraphHeader),
nameof(BoardStateParagraphText),
nameof(MovesParagraphHeader),
nameof(MovesParagraphText),
nameof(GameConstraintsParagraphHeader),
nameof(GameConstraintsParagraphText),
nameof(GameFlowParagraphHeader),
nameof(GameFlowItem1),
nameof(GameFlowItem2),
nameof(GameFlowItem3),
nameof(GameFlowItem4),
nameof(GameFlowItem5),
nameof(ExampleParagraphHeader),
nameof(ExampleParagraphText),
nameof(HintParagrapHeader),
nameof(HintParagrapText),
nameof(DisplayName));
}
public void SetDeserializedKernel(Kernel kernel)
{
if (kernel is null)
{
return;
}
Kernel = kernel;
PropertyChanged.Notify(this, "Kernel");
if (!_rangeValidator.IsValid(Kernel.Width))
{
MessageBoxExtension.ShowWarning($"Invalid kernel width={Kernel.Width}. The value has been changed to lie beetwen {minSize} and {maxSize}");
var correctedWidth = _rangeValidator.MakeValid(Kernel.Width);
Kernel.OnWidthUpdated(Kernel.Width, correctedWidth);
}
_width = Kernel.Width;
PropertyChanged.Notify(this, "Width");
if (!_rangeValidator.IsValid(Kernel.Height))
{
MessageBoxExtension.ShowWarning($"Invalid kernel height={Kernel.Height}. The value has been changed to lie beetwen {minSize} and {maxSize}");
var correctedHeight = _rangeValidator.MakeValid(Kernel.Height);
Kernel.OnHeightChanged(Kernel.Height, correctedHeight);
}
_height = Kernel.Height;
PropertyChanged.Notify(this, "Height");
}
private void WeightPropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (!_isLocked)
{
_isLocked = true;
_weightDistributionStrategy.Distribute(_listOfParameter);
_isLocked = false;
PropertyChanged.Notify(() => ToolParameter);
}
if (_listOfParameter.Where(p => p.IsLocked).Sum(p => p.Weight) >= 100)
{
foreach (var item in _listOfParameter.Where(p => p.IsActive && !p.IsLocked))
{
item.IsActive = false;
}
PropertyChanged.Notify(() => ToolParameter);
}
if ((_listOfParameter.Where(p => p.IsLocked).Sum(p => p.Weight) < 100) && (_listOfParameter.Count(p => p.IsLocked) < _listOfParameter.Count - 1))
{
foreach (var item in _listOfParameter.Where(p => !p.IsActive && !p.IsLocked))
{
item.IsActive = true;
}
PropertyChanged.Notify(() => ToolParameter);
}
}
private void OnRoomFilterVariableChanged(Guid?guid)
{
if (guid == null)
{
SelectedRoomFilter = allRoomFilter;
}
else
{
medicalPracticeRepository.RequestMedicalPractice(
medicalPractice =>
{
Application.Current.Dispatcher.Invoke(() =>
{
var room = medicalPractice.GetRoomById(guid.Value);
selectedRoomFilter = new RoomSelectorData(room.Name, room.Id, room.DisplayedColor);
PropertyChanged.Notify(this, nameof(SelectedRoomFilter));
});
},
displayedMedicalPracticeVariable.Value,
selectedDateVariable.Value,
errorCallback
);
}
}
public SalesOrderPresenter()
{
var repository = new SalesOrderRepository();
ItemsCollection = new ObservableCollection <SalesOrder>(repository.Data);
GridView.DataContext = this;
ItemView.DataContext = this;
var collectionView = CollectionViewSource.GetDefaultView(ItemsCollection);
Controllers.AddRange(
new IDisposable[]
{
new BrowseController(collectionView, ChangeCurrentItem, () => !EditableState),
new CrudController <SalesOrder>(
repository,
collectionView,
() => CurrentItem,
SetCurrent,
EditableStateChanged),
new TemplaterController(
"Templates\\SalesOrderGrid.xlsx",
"Templates\\SalesOrderItem.xlsx",
"Templates\\SalesOrderItem.docx",
"Templates\\SalesOrder.txt",
ItemsCollection,
() => GridView.dataGrid.SelectedItems),
new LayoutController(ChangeView, GridView, ItemView, GridView.dataGrid)
});
ChangeView(GridView);
PropertyChanged.Notify(() => CurrentItem);
}
private void AlphaValueToNearestAlphaSliderValue()
{
if (_alphaValue <= 0.001)
{
_alphaSliderValue = 1;
}
else if (_alphaValue <= 0.1)
{
_alphaSliderValue = 2;
}
else if (_alphaValue <= 0.5)
{
_alphaSliderValue = 3;
}
else if (_alphaValue <= 1)
{
_alphaSliderValue = 4;
}
else if (_alphaValue <= 2)
{
_alphaSliderValue = 5;
}
else if (_alphaValue <= 10)
{
_alphaSliderValue = 6;
}
else if (_alphaValue <= 1000)
{
_alphaSliderValue = 7;
}
PropertyChanged.Notify(() => AlphaSliderValue);
}
private void RefreshCaptions()
{
PropertyChanged.Notify(this, nameof(PageHeader),
nameof(Note),
nameof(Explanation01),
nameof(Explanation02),
nameof(Explanation03),
nameof(Explanation04),
nameof(Explanation05),
nameof(Explanation06),
nameof(Explanation07),
nameof(Explanation08),
nameof(Explanation09),
nameof(Explanation10),
nameof(Explanation11),
nameof(Explanation12),
nameof(Explanation13),
nameof(Explanation14),
nameof(Explanation15),
nameof(Explanation16),
nameof(Explanation17),
nameof(Explanation18),
nameof(Explanation19),
nameof(Explanation20),
nameof(Explanation21),
nameof(DisplayName));
}
private void OnPropertyValueChanged(object sender, EventArgs e)
{
NotifyStateChanged();
PropertyChanged.Notify(this, "IsActive");
PropertyChanged.Notify(this, "CurrentValue");
PropertyChanged.Notify(this, "Condition");
}
private void FieldPropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (_isLocked)
{
return;
}
_lwlcTool = ToolFactory.NewLWLCTool();
_lwlcResultDataTable = _lwlcTool.Data;
if (_selectedFeature.Fields.Count(f => f.IsSelected) >= 1)
{
_toolParameter = new BindingList <IToolParameter>(_lwlcTool.ToolParameterContainer.ToolParameter);
//ProgressDialog.ShowProgressDialog("Running LWLC Tool", (Action) _lwlcTool.Run);
ProgressDialogBuilder progressDialogBuilder = new ProgressDialogBuilder((Action <ProgressHandler>)_lwlcTool.Run);
progressDialogBuilder.SetTitle("Running LWLC Tool").Build().Show();
}
else
{
RegisterToolParameterEvents();
}
PropertyChanged.Notify(() => LWLCParameter);
PropertyChanged.Notify(() => LWLCResult);
CommandManager.InvalidateRequerySuggested();
}
private void FieldPropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (_isLocked)
{
return;
}
_wlcTool = ToolFactory.NewWLCTool();
_toolParameter = new BindingList <IToolParameter>(_wlcTool.ToolParameterContainer.ToolParameter);
if (_selectedFeature.Fields.Count(f => f.IsSelected) >= 1)
{
_wlcTool.Run();
_wlcResultDataTable = _wlcTool.Data;
}
RegisterToolParameterEvents();
PropertyChanged.Notify(() => WLCParameter);
PropertyChanged.Notify(() => WLCResult);
CommandManager.InvalidateRequerySuggested();
}
protected override void DoSendToInMemoryWorkspaceCommand()
{
_isSendToInMemoryWorkspaceCommand = !_isSendToInMemoryWorkspaceCommand;
if (_isSendToInMemoryWorkspaceCommand && !_isLocked)
{
DoLockCommand();
}
if (_isSendToInMemoryWorkspaceCommand)
{
_mcdaExtension.DisplayLink(_wlcTool);
//ProgressDialog.ShowProgressDialog("Creating Symbology", (Action<AbstractToolTemplate, DataTable>)_mcdaExtension.JoinToolResultByOID, _wlcTool, _wlcTool.Data);
ProgressDialogBuilder progressDialogBuilder = new ProgressDialogBuilder((Action <AbstractToolTemplate, DataTable>)_mcdaExtension.JoinToolResultByOID, _wlcTool, _wlcTool.Data);
progressDialogBuilder.SetTitle("Creating Symbology").SetHideCancelButton(true).SetIsIndeterminate(true).Build().Show();
}
if (!_isSendToInMemoryWorkspaceCommand)
{
DoLockCommand();
}
PropertyChanged.Notify(() => IsSendToInMemoryWorkspaceCommand);
}
//Constructor MUST be called on UI thread (we capture the UI synchronization context for use later)
public JobStore()
{
IsLocalExecution = true;
CurrentExecutionPoolText = "Local Execution";
PhysicalCoreCount = LocalPool.GetNumberOfPhysicalCores();
SelectedThreadCount = Properties.Settings.Default.SelectedThreadCount; //TODO: load setting from a previous session?
if (SelectedThreadCount == 0)
{
SelectedThreadCount = PhysicalCoreCount;
}
ThreadOptionsList = Enumerable.Range(1, USER_THREAD_COUNT_MAX).ToList();
if (PhysicalCoreCount > USER_THREAD_COUNT_MAX)
{
ThreadOptionsList.Add(PhysicalCoreCount);
}
UiTaskScheduler = TaskScheduler.FromCurrentSynchronizationContext();
TrackedJobs = new List <JobViewModel>();
Manager = new JobManagerFramework.JobManager(SelectedThreadCount);
Manager.Server.IsRemote = false;
Manager.LoadSavedJobs();
Manager.JobAdded += Manager_JobAdded;
Manager.JobCollectionAdded += JobCollectionAddedHandler;
this.TrackedJobsChanged += (sender, args) =>
{
PropertyChanged.Notify(() => HasNoRunningJobs);
};
}
private void AlphaSliderValueToAlphaValue()
{
switch (_alphaSliderValue)
{
case 1: _alphaValue = 0.001;
break;
case 2: _alphaValue = 0.1;
break;
case 3: _alphaValue = 0.5;
break;
case 4: _alphaValue = 1;
break;
case 5: _alphaValue = 2;
break;
case 6: _alphaValue = 10;
break;
case 7: _alphaValue = 1000;
break;
}
PropertyChanged.Notify(() => Alpha);
}
private void ClearSelectedPhotos()
{
Log.Debug("ClearSelectedPhotos");
AllSelectedPhotos.Clear();
SetSelectionOnAllImages(false);
PropertyChanged.Notify(() => SelectedPhotosExist);
PropertyChanged.Notify(() => SelectedPhotosCountText);
}
public FilterHandler(IImageLoader imageLoader)
{
_imageloader = imageLoader;
_imageloader.ImageLoaded += () =>
{
PropertyChanged.Notify(this, "ExecuteFilterCommand");
ResultImage = null;
};
}
private void SetHandlers()
{
PropertyChanged.Notify(() => HasConnections);
PropertyChanged.Notify(() => CommonState);
Clients.CollectionChanged += delegate { PropertyChanged.Notify(() => HasConnections); };
Clients.HandleInnerChanges(innerSelector: client => client.State,
handler: state => PropertyChanged.Notify(() => CommonState));
}
// Based on http://spotifycontrol.googlecode.com/svn/trunk/SpotifyControl/ControllerClass.vb
public void PlayPause()
{
if (!this.IsSpotifyRunning)
{
return;
}
Win32PInvoke.PostMessage(_mainWindow, 0x319, IntPtr.Zero, new IntPtr(0xE0000));
PropertyChanged.Notify(() => IsPlaying);
}
protected override void DoDistributionCommand()
{
_wlcTool.ToolParameterContainer.DistributeEquallyToolParameterWeights();
_isUpdateAllowed = true;
base.Update();
PropertyChanged.Notify(() => WLCParameter);
PropertyChanged.Notify(() => WLCResult);
}
private void AvailableFeaturesCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
foreach (var feature in Features)
{
feature.UnRegisterPropertyHandler(_listOfpropertyChangedEventHandlersForFeatureIsSelected);
}
Features = new ObservableCollection <Feature>(_mcdaExtension.AvailableFeatures.OrderByDescending(l => l.IsSuitableForMCDA).ThenBy(l => l.FeatureName).ToList());
PropertyChanged.Notify(() => Features);
}
private void DoPreviousMove()
{
if (MoveIndex <= 0)
{
return;
}
replayService.PreviousMove();
moveIndex--;
SetHighlightning(MoveIndex - 1);
PropertyChanged.Notify(this, nameof(MoveIndex));
}
private void DoNextMove()
{
if (MoveIndex >= MaxMoveIndex)
{
return;
}
replayService.NextMove();
moveIndex++;
SetHighlightning(MoveIndex - 1);
PropertyChanged.Notify(this, nameof(MoveIndex));
}
protected void RenderToPng()
{
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(Image));
using (MemoryStream stream = new MemoryStream())
{
encoder.Save(stream);
PngBytes = stream.ToArray();
}
PropertyChanged.Notify(() => Image);
}
private void JobStatusChanged(JobImpl job, Job.StatusEnum status)
{
// Notify that Status and all dependent properties have changed
PropertyChanged.Notify(() => Status);
PropertyChanged.Notify(() => AllowReRun);
PropertyChanged.Notify(() => AllowAbort);
PropertyChanged.Notify(() => ProgressMessage);
PropertyChanged.Notify(() => ProgressCurrent);
PropertyChanged.Notify(() => ProgressTotal);
PropertyChanged.Notify(() => ProgressIsIndeterminate);
}
private void ArcMapItemDeleted(object item)
{
var featureToRemove = AvailableFeatures.FirstOrDefault(f => f.ESRILayer == item);
if (featureToRemove != null && featureToRemove.IsSelected)
{
featureToRemove.IsSelected = false;
PropertyChanged.Notify(() => SelectedFeature);
}
AvailableFeatures.Remove(featureToRemove);
}
private void ElementsChanged(bool fromSelf = false)
{
if (_RaiseElementsChanged)
{
if (!fromSelf)
{
Save();
}
RemoteHub.GetBroadcastContext().RefreshControls();
_Watcher.UpdateBoundProperties(Buttons);
PropertyChanged.Notify(() => Buttons);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TriggerViewModel"/> class.
/// </summary>
public TriggerViewModel()
{
var selectedTreeItemService = ServiceLocator.Resolve <SelectedTreeItemService>();
selectedTreeItemService.SelectedTreeItemChanged += OnSelectedTreeItemChanged;
var triggerService = ServiceLocator.Resolve <TriggerService>();
Triggers = triggerService.Triggers;
Triggers.CollectionChanged += (s, e) => PropertyChanged.Notify(this, "IsEmpty");
_updateTrigger.UpdateAction = () => triggerService.UpdateTriggerList(_selectedTreeItem);
}
public void RemoveLink(AbstractToolTemplate tool)
{
Feature mcdaWorkspaceContainer;
if (!_dictionaryOfLinks.TryGetValue(tool, out mcdaWorkspaceContainer))
{
return;
}
_dictionaryOfLinks.Remove(tool);
PropertyChanged.Notify(() => LinkDictionary);
}
private void EditableStateChanged(bool inEdit)
{
EditableState = inEdit;
PropertyChanged.Notify(() => EditableState);
if (inEdit)
{
ChangeView(ItemView);
}
else
{
ChangeView(GridView);
}
}
protected override void DoDistributionCommand()
{
// in order to prevent the tool to run for every single step
_isUpdateAllowed = false;
_lwlcTool.ToolParameterContainer.DistributeEquallyToolParameterWeights();
_isUpdateAllowed = true;
base.Update();
PropertyChanged.Notify(() => LWLCParameter);
PropertyChanged.Notify(() => LWLCResult);
}
private void DoApplyNeighborhoodSelectionCommand()
{
_lwlcTool.NeighborhoodOptions = _neighborhoodSelectionViewModel.NeighborhoodOption;
_lwlcTool.NumberOfKNearestNeighbors = _neighborhoodSelectionViewModel.SelectedNumberOfKNearestNeighbors;
_lwlcTool.Threshold = _neighborhoodSelectionViewModel.Threshold;
_lwlcTool.NumberOfKNearestNeighborsForAutomatic = _neighborhoodSelectionViewModel.SelectedNumberOfKNearestNeighborsForAutomatic;
_lwlcTool.NumberOfNeighbors = _neighborhoodSelectionViewModel.NumberOfNeighbors;
_isUpdateAllowed = true;
base.Update();
PropertyChanged.Notify(() => LWLCResult);
}