public AutoFanControlModel(ILifetimeScope scope, IUIDispatcher dispatcher, FanControlOptions options)
: base(scope, dispatcher)
{
Options = RegisterProperty <FanControlOptions>(nameof(Options)).WithDefaultValue(options);
Error = RegisterProperty <bool>(nameof(Error));
Reason = RegisterProperty <string>(nameof(Reason));
Power = RegisterProperty <int>(nameof(Power));
State = RegisterProperty <State>(nameof(State));
Pidout = RegisterProperty <double>(nameof(Pidout));
PidSetValue = RegisterProperty <int>(nameof(PidSetValue));
Pt1000 = RegisterProperty <int>(nameof(Pt1000));
FanRunning = RegisterProperty <bool>(nameof(FanRunning)).WithDefaultValue(false);
Context.ActorOf("Fan-Control", Core.FanControl.FanControl.New(options));
Receive <TrackingEvent>(obs => obs.SubscribeWithStatus(evt =>
{
Error += evt.Error;
Reason += evt.Reason;
Power += evt.Power;
State += evt.State;
Pidout += evt.Pidout;
PidSetValue += evt.PidSetValue;
Pt1000 += evt.Pt1000;
}));
Receive <FanStatusChange>(obs => obs.SubscribeWithStatus(evt => FanRunning += evt.Running));
}
public TelloVideoViewModel(
IUIDispatcher dispatcher,
IUINotifier notifier,
IVideoObserver videoObserver)
: base(dispatcher, notifier)
{
_videoObserver = videoObserver ?? throw new ArgumentNullException(nameof(videoObserver));
}
public ItemAdapter(List <Item> movies)
{
items = movies;
api = Locator.Get <IApiService>();
image = Locator.Get <IImageService>();
dispatcher = Locator.Get <IUIDispatcher>();
navigator = Locator.Get <INavigationService>();
}
public MainWindowViewModel(ILifetimeScope lifetimeScope, IUIDispatcher dispatcher, IViewModel <MgiStarterControlModel> mgiStarter, IViewModel <AutoFanControlModel> autoFanControl)
: base(lifetimeScope, dispatcher)
{
this.RegisterViewModel("MgiStarter", mgiStarter);
this.RegisterViewModel("FanControl", autoFanControl);
NewCommad
.WithExecute(ShowWindow <LogWindow>)
.ThenRegister("OpenLogs");
}
public MainPage()
{
InitializeComponent();
_dispatcher = new UIDispatcher(SynchronizationContext.Current);
_notifier = new UINotifier();
ViewModel = CreateMainViewModel(_dispatcher, _notifier);
DataContext = ViewModel;
ViewModel.ControllerViewModel.PropertyChanged += ControllerViewModel_PropertyChanged;
}
public PayloadProcessorBase(IRadioObject payload, IEnvironment env, ILog log, IEnumerable <MototrboRadio> radios, ITransmitter transmitter, IUIDispatcher uiDispatcher)
{
_env = env;
_log = log;
_radios = radios;
_transmitter = transmitter;
_uiDispatcher = uiDispatcher;
rxObject = payload;
_radio = GetRadio(payload.Ip);
}
public MainPage()
{
this.InitializeComponent();
this.dispatcher = new UIDispatcher(SynchronizationContext.Current);
this.notifier = new UINotifier();
this.ViewModel = this.CreateMainViewModel(this.dispatcher, this.notifier);
this.DataContext = this.ViewModel;
this.ViewModel.ControllerViewModel.PropertyChanged += this.ControllerViewModel_PropertyChanged;
}
public TelloStateViewModel(
IUIDispatcher dispatcher,
IUINotifier notifier,
IStateObserver stateObserver,
IRepository repository,
ISession session)
: base(dispatcher, notifier)
{
this.stateObserver = stateObserver ?? throw new ArgumentNullException(nameof(stateObserver));
this.repository = repository ?? throw new ArgumentNullException(nameof(repository));
this.session = session ?? throw new ArgumentNullException(nameof(session));
}
public TelloControllerViewModel(
IUIDispatcher dispatcher,
IUINotifier notifier,
IFlightController controller,
IRepository repository,
ISession session)
: base(dispatcher, notifier)
{
this.controller = controller ?? throw new ArgumentNullException(nameof(controller));
this.repository = repository ?? throw new ArgumentNullException(nameof(repository));
this.session = session ?? throw new ArgumentNullException(nameof(session));
}
public RxProcessor(IEnvironment env, ILog log, IEventAggregator aggregator, IEnumerable <MototrboRadio> radios, ITransmitter transmitter, IUIDispatcher uiDispatcher)
{
_env = env;
_log = log;
_aggregator = aggregator;
_radios = radios;
_transmitter = transmitter;
_uiDispatcher = uiDispatcher;
_receiverQueue = new ConcurrentQueue <RxObject>();
_rxPoolThread = new Thread(new ThreadStart(Process));
}
static void Main(string[] args)
{
try {
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Form mainForm = new PicasaUploaderForm(args);
UIDispatcher = (IUIDispatcher)mainForm;
Application.Run(mainForm);
} catch (Exception e) {
UnhandledExceptionHandler(e);
}
}
public ServerManager(IEnvironment env, ILog logger, IEventAggregator aggregator, IEnumerable<MototrboRadio> radios, ILog consoleLog)
{
_env = env;
_log = logger;
_aggregator = aggregator;
_radios = radios;
_consoleLog = consoleLog;
_transmitter = new Transmiter(_env, _log, _aggregator, _consoleLog);
_uiDispatcher = new UIDispatcher(_env, _log, _aggregator);
_rxProcessor = new RxProcessor(_env, _log, _aggregator, _radios, _transmitter, _uiDispatcher);
_serviceList = new Dictionary<int, IReceiver>();
}
public CenterViewModel(ILifetimeScope lifetimeScope, IUIDispatcher dispatcher, IOperationManager manager,
LocLocalizer localizer, IDialogCoordinator dialogCoordinator,
IMainWindowCoordinator mainWindow, ProjectFileWorkspace workspace)
: base(lifetimeScope, dispatcher)
{
var proxy = Context.ActorOf <ObservableActor>("Loading_Proxy");
this.Receive <IncommingEvent>(e => e.Action());
Views = this.RegisterUiCollection <ProjectViewContainer>(nameof(Views)).BindToList(out var viewList);
CurrentProject = RegisterProperty <int?>(nameof(CurrentProject));
AddProject(new Project {
ProjectName = "Dummy"
});
public MainPage()
{
this.InitializeComponent();
// Initialize helper class used to render the skill results on screen
m_bboxRenderer = new BoundingBoxRenderer(UIOverlayCanvas);
m_processedBitmapSource = new SoftwareBitmapSource();
PopulateCommands();
ApiContainer.Register <ComputerVisionService>(new ComputerVisionService());
this.dispatcher = new UIDispatcher(SynchronizationContext.Current);
this.notifier = new UINotifier();
this.ViewModel = this.CreateMainViewModel(this.dispatcher, this.notifier);
this.DataContext = this.ViewModel;
this.ViewModel.ControllerViewModel.PropertyChanged += this.ControllerViewModel_PropertyChanged;
isListening = false;
}
public DocumentEditorViewModel(
JObject document,
bool isNew,
IContainerContext containerContext,
IDialogService dialogService,
IUIDispatcher uiDispatcher)
{
_document = document;
_isNew = isNew;
_containerContext = containerContext;
_dialogService = dialogService;
_uiDispatcher = uiDispatcher;
_validateJsonTimer = new Timer(
state =>
{
var @this = ((DocumentEditorViewModel)state !);
@this._uiDispatcher.Invoke(() => @this.ValidateJson());
},
this,
Timeout.Infinite,
Timeout.Infinite);
if (_isNew)
{
Title = "New document";
}
else
{
Title = "Edit document";
}
_id = document["id"].Value <string>();
_eTag = document["_etag"]?.Value <string>();
_text = document.ToString(Formatting.Indented);
_isJsonValid = true;
base.AddButton(new DialogButton
{
Text = "Close",
Command = new DelegateCommand(() => Close(null)),
IsCancel = true
});
}
public MainViewModel(
IUIDispatcher dispatcher,
IUINotifier notifier,
IRepository repository,
ITransceiver transceiver,
IReceiver stateReceiver,
IReceiver videoReceiver)
: base(dispatcher, notifier)
{
this.tello = new DroneMessenger(transceiver, stateReceiver, videoReceiver);
repository.CreateCatalog <Session>();
repository.CreateCatalog <ObservationGroup>();
repository.CreateCatalog <StateObservation>();
repository.CreateCatalog <AirSpeedObservation>();
repository.CreateCatalog <AttitudeObservation>();
repository.CreateCatalog <BatteryObservation>();
repository.CreateCatalog <HobbsMeterObservation>();
repository.CreateCatalog <PositionObservation>();
repository.CreateCatalog <ResponseObservation>();
var session = repository.NewEntity <Session>();
this.StateViewModel = new TelloStateViewModel(
dispatcher,
notifier,
this.tello.StateObserver,
repository,
session);
this.VideoViewModel = new TelloVideoViewModel(
dispatcher,
notifier,
this.tello.VideoObserver);
this.ControllerViewModel = new TelloControllerViewModel(
dispatcher,
notifier,
this.tello.Controller,
repository,
session);
}
public LogWindowViewModel(ILifetimeScope lifetimeScope, IUIDispatcher dispatcher)
: base(lifetimeScope, dispatcher)
{
UnhandledMessages = this.RegisterUiCollection <string>(nameof(UnhandledMessages)).BindToList(out var list);
list.Add("Start");
this.SubscribeToEvent <UnhandledMessage>(obs =>
obs
.SubscribeWithStatus(obj =>
{
var builder = new StringBuilder($"Name: {obj.GetType().Name}");
foreach (var propertyInfo in obj.Message.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
builder.Append($" - {propertyInfo.GetValue(obj.Message)}");
}
list.Add(builder.ToString());
}));
}
private MainViewModel CreateMainViewModel(IUIDispatcher dispatcher, IUINotifier notifier)
{
#if EMULATOR_ON
_simulator = new DroneSimulator();
var transceiver = new SimTransceiver(_simulator.MessageHandler);
var stateReceiver = new SimReceiver(_simulator.StateTransmitter);
var videoReceiver = new SimReceiver(_simulator.VideoTransmitter);
#else
var transceiver = new UdpTransceiver(IPAddress.Parse("192.168.10.1"), 8889);
var stateReceiver = new UdpReceiver(8890);
var videoReceiver = new UdpReceiver(11111);
#endif
return(new MainViewModel(
this.dispatcher,
this.notifier,
new SqliteRepository((null, "tello.sqlite")),
transceiver,
stateReceiver,
videoReceiver));
}
public ArsProcessor(IRadioObject payload, IEnvironment env, ILog log, IEnumerable <MototrboRadio> radios, ITransmitter transmitter, IUIDispatcher uiDispatcher)
: base(payload, env, log, radios, transmitter, uiDispatcher)
{
_action = () =>
{
string radioIp = payload.Ip;
if (_radio != null)
{
var data = payload.Buffer;
var currentDate = DateTime.Now;
UIObject toFrontEnd = new UIObject();
int PayloadDecimal = 0;
if (data.Length > 3)
{
int a = data[2];
int b = data[3];
PayloadDecimal = a + b;
}
else
{
int a = data[1];
int b = data[2];
PayloadDecimal = a + b;
}
_radio.IsOn = true;
_radio.IsOff = false;
_radio.IsUnknow = false;
switch (PayloadDecimal)
{
case 272:
//eventoARS.EstadoARS = 1 'RADIO ON
_radio.evento = 1;
_radio.dates[0].date = currentDate;
toFrontEnd.MethodName = "arsOn";
//Ars Acknowledge transmit
_transmitter.Add(ARSAcknowledge());
if (_radio.gps_on)
{
//Gps Interval enabling
_transmitter.Add(GPSIntervalRequest());
//Emergency enabling
_transmitter.Add(GPSEmergencyEnabledRequest());
}
break;
case 64:
//eventoARS.EstadoARS = 2 'RADIO UPDATE
RemoveTxData(_env.PortArs);
//Gps Interval enabling
if (_radio.gps_on)
{
//Gps Interval enabling
_transmitter.Add(GPSIntervalRequest());
//Emergency enabling
_transmitter.Add(GPSEmergencyEnabledRequest());
}
_radio.dates[0].date = currentDate;
toFrontEnd.MethodName = "arsOn";
_radio.evento = 3;
break;
case 304:
//eventoARS.EstadoARS = 2 'RADIO UPDATE
RemoveTxData(_env.PortArs);
_radio.dates[0].date = currentDate;
toFrontEnd.MethodName = "arsOn";
_radio.evento = 3;
break;
case 50:
case 81:
//eventoARS.EstadoARS = 3 'RADIO OFF
RemoveTxData(_env.PortArs);
_radio.IsOn = false;
_radio.IsOff = true;
_radio.hasGpsPosition = false;
_radio.dates[1].date = currentDate;
toFrontEnd.MethodName = "arsOff";
_radio.evento = 2;
break;
}
toFrontEnd.Id = payload.Id;
toFrontEnd.Radio = _radio;
_uiDispatcher.Add(toFrontEnd);
Task.Run(() =>
{
RadiosDomain.Save(_radio);
});
Task.Run(() =>
{
ArsDataDomain.Save(_radio);
});
}
};
}
public ProjectViewModel(ILifetimeScope lifetimeScope, IUIDispatcher dispatcher, LocLocalizer localizer,
ProjectFileWorkspace workspace)
: base(lifetimeScope, dispatcher)
{
#region Init
Languages = this.RegisterUiCollection <ProjectViewLanguageModel>(nameof(Languages))
.BindToList(out var languages);
ProjectEntrys = this.RegisterUiCollection <ProjectEntryModel>(nameof(ProjectEntrys))
.BindToList(out var projectEntrys);
ImportetProjects = this.RegisterUiCollection <string>(nameof(ImportetProjects))
.BindToList(out var importprojects);
var loadTrigger = new Subject <Unit>();
this.Receive <IncommingEvent>(e => e.Action());
IsEnabled = RegisterProperty <bool>(nameof(IsEnabled)).WithDefaultValue(!workspace.ProjectFile.IsEmpty);
SelectedIndex = RegisterProperty <int>(nameof(SelectedIndex));
var self = Context.Self;
void TryUpdateEntry((string ProjectName, string EntryName, ActiveLanguage Lang, string Content) data)
{
var(projectName, entryName, lang, content) = data;
self.Tell(new UpdateRequest(entryName, lang, content, projectName));
}
void TryRemoveEntry((string ProjectName, string EntryName) data)
{
var(projectName, entryName) = data;
self.Tell(new RemoveRequest(entryName, projectName));
}
Start.Subscribe(_ => Self.Tell(new InitProjectViewModel(workspace.Get(_project))));
void InitProjectViewModel(InitProjectViewModel obj)
{
_project = obj.Project.ProjectName;
languages.Edit(l =>
{
l.Add(new ProjectViewLanguageModel(localizer.ProjectViewLanguageBoxFirstLabel, true));
l.AddRange(obj.Project.ActiveLanguages.Select(al => new ProjectViewLanguageModel(al.Name, false)));
});
SelectedIndex += 0;
projectEntrys.AddRange(obj.Project.Entries.OrderBy(le => le.Key).Select(le
=> new ProjectEntryModel(obj.Project, le, TryUpdateEntry, TryRemoveEntry)));
importprojects.AddRange(obj.Project.Imports);
loadTrigger.OnNext(Unit.Default);
}
this.Receive <InitProjectViewModel>(InitProjectViewModel);
#endregion
#region New Entry
IEnumerable <NewEntryInfoBase> GetEntrys()
{
var list = ImportetProjects !.ToList();
list.Add(_project);
var allEntrys = list.SelectMany(pro => workspace.Get(pro).Entries.Select(e => e.Key)).ToArray();
return(allEntrys.Select(e => new NewEntryInfo(e)).OfType <NewEntryInfoBase>()
.Concat(allEntrys
.Select(s => s.Split('_', StringSplitOptions.RemoveEmptyEntries).FirstOrDefault())
.Where(s => !string.IsNullOrWhiteSpace(s))
.Distinct(StringComparer.Ordinal)
.Select(s => new NewEntrySuggestInfo(s !))));
}
void AddEntry(EntryAdd entry)
{
if (_project != entry.Entry.Project)
{
return;
}
projectEntrys.Add(new ProjectEntryModel(workspace.Get(_project), entry.Entry, TryUpdateEntry,
TryRemoveEntry));
}
NewCommad.WithFlow(ob => ob.Select(_ => GetEntrys())
.Dialog(this).Of <INewEntryDialog, NewEntryDialogResult?>()
.NotNull()
.Mutate(workspace.Entrys).With(em => em.EntryAdd, em => res => em.NewEntry(_project, res.Name))
.ObserveOnSelf()
.Subscribe(AddEntry))
.ThenRegister("NewEntry");
#endregion
#region Remove Request
void RemoveEntry(EntryRemove entry)
{
if (_project != entry.Entry.Project)
{
return;
}
var index = ProjectEntrys !.FindIndex(em => em.EntryName == entry.Entry.Key);
if (index == -1)
{
return;
}
projectEntrys !.RemoveAt(index);
}
Receive <RemoveRequest>(obs => obs.Mutate(workspace.Entrys)
.With(em => em.EntryRemove, em => rr => em.RemoveEntry(rr.ProjectName, rr.EntryName))
.ObserveOnSelf()
.Subscribe(RemoveEntry));
#endregion
#region Update Request
void UpdateEntry(EntryUpdate obj)
{
if (_project != obj.Entry.Project)
{
return;
}
var model = ProjectEntrys !.FirstOrDefault(m => m.EntryName == obj.Entry.Key);
model?.Update(obj.Entry);
}
Receive <UpdateRequest>(obs => obs.Mutate(workspace.Entrys).With(em => em.EntryUpdate,
em => ur => em.UpdateEntry(ur.ProjectName, ur.Language, ur.EntryName, ur.Content))
.ObserveOnSelf()
.Subscribe(UpdateEntry));
#endregion
#region Imports
void AddImport(AddImport obj)
{
var(projectName, import) = obj;
if (projectName != _project)
{
return;
}
importprojects !.Add(import);
}
IEnumerable <string> GetImportableProjects()
{
var pro = workspace.Get(_project);
return(workspace.ProjectFile.Projects.Select(p => p.ProjectName)
.Where(p => p != _project && !pro.Imports.Contains(p)));
}
ImportSelectIndex = RegisterProperty <int>(nameof(ImportSelectIndex)).WithDefaultValue(-1);
NewCommad.WithCanExecute(from trigger in loadTrigger
select GetImportableProjects().Any())
.WithFlow(ob => ob.Select(_ => GetImportableProjects())
.Dialog(this).Of <IImportProjectDialog, ImportProjectDialogResult?>()
.NotNull()
.Mutate(workspace.Projects).With(pm => pm.NewImport, pm => r => pm.AddImport(_project, r.Project))
.ObserveOnSelf()
.Subscribe(AddImport))
.ThenRegister("AddImport");
void RemoveImport(RemoveImport import)
{
var(targetProject, toRemove) = import;
if (_project != targetProject)
{
return;
}
importprojects !.Remove(toRemove);
}
NewCommad.WithCanExecute(ImportSelectIndex.Select(i => i != -1))
.WithFlow(ob => ob.Select(_ => new InitImportRemove(ImportetProjects[ImportSelectIndex]))
.Mutate(workspace.Projects).With(pm => pm.RemoveImport,
pm => ir => pm.TryRemoveImport(_project, ir.ToRemove))
.Subscribe(RemoveImport))
.ThenRegister("RemoveImport");
workspace.Projects.NewImport.ToUnit().Subscribe(loadTrigger).DisposeWith(this);
workspace.Projects.RemoveImport.ToUnit().Subscribe(loadTrigger).DisposeWith(this);
#endregion
#region AddLanguage
void AddActiveLanguage(AddActiveLanguage language)
{
if (language.ProjectName != _project)
{
return;
}
languages.Add(new ProjectViewLanguageModel(language.ActiveLanguage.Name, false));
foreach (var model in ProjectEntrys)
{
model.AddLanguage(language.ActiveLanguage);
}
}
NewCommad.WithFlow(ob => ob
.Select(_ => workspace.Get(_project).ActiveLanguages.Select(al => al.ToCulture()).ToArray())
.Dialog(this).Of <ILanguageSelectorDialog, AddLanguageDialogResult?>()
.NotNull()
.Mutate(workspace.Projects)
.With(pm => pm.NewLanguage, pm => d => pm.AddLanguage(_project, d.CultureInfo))
.Subscribe(AddActiveLanguage))
.ThenRegister("AddLanguage");
#endregion
}
public MainWindowViewModel(ILifetimeScope lifetimeScope, IUIDispatcher dispatcher,
IOperationManager operationManager, LocLocalizer localizer, IDialogCoordinator dialogCoordinator,
AppConfig config, IDialogFactory dialogFactory, IViewModel <CenterViewModel> model,
IMainWindowCoordinator mainWindowCoordinator, ProjectFileWorkspace workspace)
: base(lifetimeScope, dispatcher)
{
this.Receive <IncommingEvent>(e => e.Action());
var last = new RxVar <ProjectFile?>(null);
var loadingOperation = new RxVar <OperationController?>(null);
var self = Self;
CenterView = this.RegisterViewModel(nameof(CenterView), model);
workspace.Source.ProjectReset.RespondOn(null, pr => last.Value = pr.ProjectFile);
#region Restarting
Start.Subscribe(_ =>
{
if (last != null)
{
Self.Tell(last);
}
});
this.Receive <ProjectFile>(workspace.Reset);
#endregion
#region Operation Manager
RunningOperations = RegisterProperty <IEnumerable <RunningOperation> >(nameof(RunningOperations))
.WithDefaultValue(operationManager.RunningOperations);
RenctFiles = RegisterProperty <RenctFilesCollection>(nameof(RenctFiles))
.WithDefaultValue(new RenctFilesCollection(config, s => self.Tell(new InternlRenctFile(s))));
NewCommad.WithExecute(operationManager.Clear, operationManager.ShouldClear()).ThenRegister("ClearOp");
NewCommad.WithExecute(operationManager.CompledClear, operationManager.ShouldCompledClear())
.ThenRegister("ClearAllOp");
#endregion
#region Save As
IObservable <UpdateSource> SaveAsProject()
{
var targetFile = dialogFactory.ShowSaveFileDialog(null, true, false, true, "transp", true,
localizer.OpenFileDialogViewDialogFilter, true, true, localizer.MainWindowMainMenuFileSaveAs,
Directory.GetCurrentDirectory());
return(targetFile.NotEmpty()
.SelectMany(CheckSourceOk)
.Where(d => d.Item1)
.Select(r => new UpdateSource(r.Item2)));
}
async Task <(bool, string)> CheckSourceOk(string source)
{
if (!string.IsNullOrWhiteSpace(source))
{
return(true, source);
}
await UICall(()
=> dialogCoordinator.ShowMessage(localizer.CommonError,
localizer.MainWindowModelLoadProjectSourceEmpty !));
return(false, source);
}
NewCommad.WithCanExecute(last.Select(pf => pf != null && !pf.IsEmpty))
.WithFlow(ob => ob.SelectMany(_ => SaveAsProject())
.ToModel(CenterView))
.ThenRegister("SaveAs");
#endregion
#region Open File
IDisposable NewProjectFile(IObservable <SourceSelected> source) => source
.SelectMany(SourceSelectedFunc)
.NotNull()
.ObserveOnSelf()
.Select(ProjectLoaded)
.ToModel(CenterView !);
this.Receive <InternlRenctFile>(o => OpentFileSource(o.File));
IObservable <LoadedProjectFile?> SourceSelectedFunc(SourceSelected s)
{
if (s.Mode != OpenFileMode.OpenExistingFile)
{
return(NewFileSource(s.Source));
}
OpentFileSource(s.Source);
return(Observable.Return <LoadedProjectFile?>(null));
}
void OpentFileSource(string?rawSource)
{
Observable.Return(rawSource)
.NotEmpty()
.SelectMany(CheckSourceOk)
.Select(p => p.Item2)
.Do(_ => mainWindowCoordinator.IsBusy = true)
.SelectMany(source => operationManager
.StartOperation(string.Format(localizer.MainWindowModelLoadProjectOperation,
Path.GetFileName(source)))
.Do(op => loadingOperation !.Value = op)
.Select(operationController => (operationController, source)))
.Do(_ =>
{
if (!workspace.ProjectFile.IsEmpty)
{
workspace.ProjectFile.Operator.Tell(ForceSave.Force(workspace.ProjectFile));
}
})
.ObserveOnSelf()
.Subscribe(pair
=> ProjectFile.BeginLoad(Context, pair.operationController.Id, pair.source,
"Project_Operator"));
}
SupplyNewProjectFile?ProjectLoaded(LoadedProjectFile obj)
{
try
{
if (loadingOperation !.Value != null)
{
if (obj.Ok)
{
loadingOperation.Value.Compled();
}
else
{
loadingOperation.Value.Failed(obj.ErrorReason?.Message ?? localizer.CommonError);
return(null);
}
}
loadingOperation.Value = null;
if (obj.Ok)
{
RenctFiles !.Value.AddNewFile(obj.ProjectFile.Source);
}
last !.Value = obj.ProjectFile;
return(new SupplyNewProjectFile(obj.ProjectFile));
}
finally
{
mainWindowCoordinator.IsBusy = false;
}
}
NewCommad.WithCanExecute(loadingOperation.Select(oc => oc == null))
.WithFlow(obs => NewProjectFile(obs.Dialog(this, TypedParameter.From(OpenFileMode.OpenExistingFile))
.Of <IOpenFileDialog, string?>()
.Select(s => SourceSelected.From(s, OpenFileMode.OpenExistingFile))))
.ThenRegister("OpenFile");
NewProjectFile(Receive <SourceSelected>()).DisposeWith(this);
Receive <LoadedProjectFile>(ob => ob.Select(ProjectLoaded).ToModel(CenterView !));
#endregion
#region New File
IObservable <LoadedProjectFile?> NewFileSource(string?source)
{
source ??= string.Empty;
var data = new LoadedProjectFile(string.Empty,
ProjectFile.NewProjectFile(Context, source, "Project_Operator"), null, true);
if (File.Exists(source))
{
//TODO NewFile Filog Message
var result = UICall(async()
=> await dialogCoordinator.ShowMessage(localizer.CommonError !, "", null));
return(result.Where(b => b == true).Do(_ => mainWindowCoordinator.IsBusy = true).Select(_ => data));
}
mainWindowCoordinator.IsBusy = true;
return(Observable.Return(data));
}
NewCommad.WithCanExecute(loadingOperation.Select(oc => oc == null))
.WithFlow(obs => obs.Dialog(this, TypedParameter.From(OpenFileMode.OpenNewFile))
.Of <IOpenFileDialog, string?>()
.Select(s => SourceSelected.From(s, OpenFileMode.OpenNewFile))
.ToSelf())
.ThenRegister("NewFile");
#endregion
#region Analyzing
AnalyzerEntries = this.RegisterUiCollection <AnalyzerEntry>(nameof(AnalyzerEntries))
.BindToList(out var analyterList);
var builder = new AnalyzerEntryBuilder(localizer);
void IssuesChanged(IssuesEvent obj)
{
analyterList.Edit(l =>
{
var(ruleName, issues) = obj;
l.Remove(AnalyzerEntries.Where(e => e.RuleName == ruleName));
l.AddRange(issues.Select(builder.Get));
});
}
this.RespondOnEventSource(workspace.Analyzer.Issues, IssuesChanged);
#endregion
#region Build
var buildModel = lifetimeScope.Resolve <IViewModel <BuildViewModel> >();
buildModel.InitModel(Context, "Build-View");
BuildModel = RegisterProperty <IViewModel <BuildViewModel> >(nameof(BuildModel)).WithDefaultValue(buildModel);
#endregion
}
public DialogFactory(IUIDispatcher currentDispatcher, IMainWindow mainWindow)
{
_mainWindow = ((WpfWindow)mainWindow.Window).Window;
CurrentDispatcher = currentDispatcher;
}
private DispatcherScheduler(IUIDispatcher dispatcher) => _dispatcher = dispatcher;
public ViewConnector(string name, DataContextPromise promise, Action <object> updater, IUIDispatcher dispatcher)
: base(name, promise)
{
_updater = updater;
_dispatcher = dispatcher;
}
public SmsProcessor(IRadioObject payload, IEnvironment env, ILog log, IEnumerable <MototrboRadio> radios, ITransmitter transmitter, IUIDispatcher uiDispatcher)
: base(payload, env, log, radios, transmitter, uiDispatcher)
{
_action = () =>
{
string radioIp = payload.Ip;
DateTime currentDate = DateTime.Now;
if (_radio != null)
{
byte[] Data = payload.Buffer;
UIObject toFrontEnd = new UIObject();
if (Data[2] == 191)
{
_radio.IsInsmsSending = false;
RemoveTxData(_env.PortSms);
}
if (Data[2] != 191)
{
//Sms acknowloedge
_transmitter.Add(SMSAcknowledge());
//
byte[] textB = Data.Skip(10 + Data[3]).ToArray();
string Text = System.Text.Encoding.Unicode.GetString(textB);
SmsDataTable dataTable = new SmsDataTable()
{
de = _radio.radio_id.ToString(),
evento = 9,
fecha = DateTime.Now,
para = _radio.despacho,
sms = Text,
sms_id = -1
};
_radio.message = Text;
_radio.dates[3].date = DateTime.Now;
toFrontEnd.MethodName = "smsIn";
toFrontEnd.Radio = _radio;
_uiDispatcher.Add(toFrontEnd);
Task.Run(() =>
{
RadiosDomain.Save(_radio);
});
Task.Run(() =>
{
SmsInDataDomain.Save(dataTable);
});
}
}
};
}
/// <summary>
/// Initializes a new instance of the <see cref="AppDialog"/> class.
/// </summary>
/// <param name="dispatcher">
/// The dispatcher for launching dialogs on the UI thread.
/// </param>
public AppDialog(IUIDispatcher dispatcher)
{
this.dispatcher = dispatcher;
this.dialogSemaphore = new SemaphoreSlim(1, 1);
}
public static void Init(IUIDispatcher dispatcher)
{
if (UIDispatcher.current == null)
UIDispatcher.current = dispatcher;
}
public MgiStarterControlModel(ILifetimeScope lifetimeScope, IUIDispatcher dispatcher, ProcessConfig config, IDialogFactory dialogFactory)
: base(lifetimeScope, dispatcher)
{
Client = RegisterProperty <Process?>(nameof(Client)).OnChange(UpdateLabel);
Kernel = RegisterProperty <Process?>(nameof(Kernel)).OnChange(UpdateLabel);
Status = RegisterProperty <string?>(nameof(Status)).OnChange(UpdateLabel);
InternalStart = RegisterProperty <bool>(nameof(InternalStart)).OnChange(UpdateLabel);
StatusLabel = RegisterProperty <string?>(nameof(StatusLabel));
_localHelper = new LocalHelper(Context);
_config = config;
_processManager = Context.ActorOf("Process-Manager", ProcessManagerActor.New());
var mgiStarting = Context.ActorOf("Mgi-Starter", MgiStartingActor.New(dialogFactory));
var currentStart = new BehaviorSubject <CancellationTokenSource?>(null).DisposeWith(this);
(from start in currentStart
from state in InternalStart
where !state
select start
).SubscribeWithStatus(s => s?.Dispose())
.DisposeWith(this);
Receive <ProcessStateChange>(obs => obs.SubscribeWithStatus(ProcessStateChangeHandler));
Receive <MgiStartingActor.TryStartResponse>(obs => obs.SubscribeWithStatus(_ =>
{
currentStart.OnNext(null);
InternalStart += false;
}));
Receive <MgiStartingActor.StartStatusUpdate>(obs => obs.SubscribeWithStatus(s => Status += s.Status));
NewCommad
.WithCanExecute(InternalStart.Select(b => !b))
.WithExecute(() =>
{
InternalStart += true;
currentStart.OnNext(new CancellationTokenSource());
mgiStarting.Tell(new MgiStartingActor.TryStart(_config, currentStart.Value !.Token,
() =>
{
Client.Value?.Kill(true);
Kernel.Value?.Kill(true);
}));
}).ThenRegister("TryStart");
NewCommad
.WithCanExecute(from client in Client
select client != null)
.WithCanExecute(from kernel in Kernel
select kernel != null)
.WithExecute(() =>
{
currentStart.Value?.Cancel();
Client.Value?.Kill(true);
Kernel.Value?.Kill(true);
}).ThenRegister("TryStop");
InternalStart += false;
UpdateLabel();
}
public ViewModel(IUIDispatcher dispatcher, IUINotifier userNotifier)
: base(dispatcher)
{
this.DisplayName = $"#{this.GetType().Name}#";
this.UserNotifier = userNotifier ?? throw new ArgumentNullException(nameof(userNotifier));
}
public GpsProcessor(IRadioObject payload, IEnvironment env, ILog log, IEnumerable <MototrboRadio> radios, ITransmitter transmitter, IUIDispatcher uiDispatcher)
: base(payload, env, log, radios, transmitter, uiDispatcher)
{
_action = () =>
{
string radioIp = payload.Ip;
int DatumIndexStart = 9;
bool HasGpsData = false;
if (_radio != null)
{
byte[] Data = payload.Buffer;
UIObject toFrontEnd = new UIObject();
_radio.emerg_on = false;
if (!_radio.IsOn)
{
_radio.IsOn = true;
_radio.IsOff = false;
_radio.IsUnknow = false;
}
//Localizacion instantanea correcta
if (Data[0] == 7 & !(Data[1] == 0xc))
{
HasGpsData = true;
_radio.evento = 6;
DatumIndexStart = 15;
RemoveTxData(_env.PortGps, new byte[] { 0x05, 0x08, 0x22, 0x04, 0x24, 0x68, 0xAC, 0xE0, 0x51, 0x62 });
}
//GPS instantaneo respuesta acknowledge.
if (Data[0] == 0xb)
{
_radio.IsInIntervalLocationSending = false;
RemoveTxData(_env.PortGps, new byte[] { 0x05, 0x08, 0x22, 0x04, 0x24, 0x68, 0xAC, 0xE0, 0x51, 0x62 });
}
//GPS localizacion intervalo correcta
if (Data[0] == 0xd & !(Data[1] == 0xc))
{
if (string.IsNullOrEmpty(_radio.latitud))
{
RemoveTxData(_env.PortGps, DataToSend.GPS_INTERVAL_ON);
}
_radio.evento = 7;
HasGpsData = true;
}
//GPS localizacion intervalo stop
if (Data[0] == 0xb && Data[1] == 0x07)
{
RemoveTxData(_env.PortGps, DataToSend.GPS_INTERVAL_OFF);
}
if ((Data[0] == 0xb & Data[7] == 0xe1))
{
_radio.IsInEmergencySending = false;
RemoveTxData(_env.PortGps, DataToSend.EMERGENCY_ON);
}
if ((Data[0] == 0xd & Data[7] == 0xe1))
{
_transmitter.Add(GPSEmergencyEnabledRequest());
_radio.latitud = "0";
_radio.longitud = "0";
_radio.velocidad = "0";
_radio.dates[2].date = DateTime.Now;
_radio.emerg_on = true;
_radio.evento = 8;
if (!(Data[8] == 0x37 || Data[8] == 0x38))
{
HasGpsData = true;
}
toFrontEnd.MethodName = "emergency";
}
if (HasGpsData)
{
_radio.IsInInstantLocationSending = false;
//List<double> GpsDatum = ResolveDatum(DatumIndexStart, DatumIndexStart + 4, Data);
Helpers.GpsDatum Datum = new Helpers.GpsDatum(DatumIndexStart, DatumIndexStart + 4, Data);
_radio.latitud = Datum.latitude.ToString().Replace(",", ".");
_radio.longitud = Datum.longitude.ToString().Replace(",", ".");
_radio.velocidad = Datum.speed.ToString().Replace(",", ".");
_radio.hasGpsPosition = true;
_radio.dates[2].date = DateTime.Now;
if (!_radio.emerg_on)
{
toFrontEnd.MethodName = "gpsData";
}
}
toFrontEnd.Radio = _radio;
_uiDispatcher.Add(toFrontEnd);
Task.Run(() =>
{
GpsDataDomain.Save(_radio);
});
Task.Run(() =>
{
RadiosDomain.Save(_radio);
});
}
};
}
public WindowService(IUIDispatcher dispatcher)
{
_dispatcher = dispatcher;
}
public PropertyChangedNotifier(IUIDispatcher dispatcher)
{
Dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
}
