public CameraClientViewModel()
{
FramesProcessed += async f => { await Task.Yield(); };
Cameras = new CollectionViewSource();
Resolutions = new CollectionViewSource();
Dispatcher = Cameras.Dispatcher;
CurrentImage = this.NewProperty(x => x.CurrentImage);
SelectedCamera = this.NewProperty(x => x.SelectedCamera);
SelectedResolution = this.NewProperty(x => x.SelectedResolution);
Countdown = this.NewProperty(x => x.Countdown);
CountdownVisible = this.NewProperty(x => x.CountdownVisible);
RecordingVisibility = this.NewProperty(x => x.RecordingVisibility);
CountdownVisible.Value = Visibility.Collapsed;
RecordingVisibility.Value = Visibility.Collapsed;
_controller = new ClientController();
_controller.PrepareForRecording += PrepareForRecording;
_controller.RecordingStarted += RecordingStarted;
_controller.RecordingCompleted += RecordingCompleted;
Record = new ActionCommand(RecordVideo);
SelectedCamera.Changed += SelectedCameraChanged;
SelectedResolution.Changed += SelectedResolutionChanged;
_remote = new CameraClientRemoteControl(this, _controller);
}
public ShowPartyInviteesViewModel(IPartyInviteeRepository repository)
{
_repository = repository;
Add = new ActionCommand(OnAdd);
BetterAdd = new ActionCommand(OnBetterAdd);
RefreshList();
}
public SniperInfoModel()
{
copyCoordsCommand = new ActionCommand(CopyCoords);
PokeSnipersCommand = new ActionCommand(PokeSnipers);
SniperVisibility = GlobalSettings.SniperVisibility;
Created = DateTime.Now;
}
/// <summary>
/// Initializes a new instance of the <see cref="PersonViewModel"/> class.
/// </summary>
public PersonViewModel()
{
ToggleReadOnlyCommand = new ActionCommand(ToggleReadOnly);
FirstName = "First Name";
LastName = "Last Name";
}
protected override void InternalExecute(ICommandAdapter adapter){
var actionCommand = new ActionCommand();
var parameterList = actionCommand.Parameters;
parameterList.MainParameter=new MainParameter("Navigation");
parameterList.ExtraParameter = Parameters.MainParameter;
actionCommand.Execute(adapter);
}
public MainWindowViewModel() {
Pokemons = new ReadOnlyObservableCollection<SniperInfoModel>(GlobalVariables.PokemonsInternal);
SettingsComand = new ActionCommand(ShowSettings);
StartStopCommand = new ActionCommand(Startstop);
DebugComand = new ActionCommand(ShowDebug);
Settings.Default.DebugOutput = "Debug stuff in here!";
//var poke = new SniperInfo {
// Id = PokemonId.Missingno,
// Latitude = 45.99999,
// Longitude = 66.6677,
// ExpirationTimestamp = DateTime.Now
//};
//var y = new SniperInfoModel {
// Info = poke,
// Icon = new BitmapImage(new Uri(Path.Combine(iconPath, $"{(int) poke.Id}.png")))
//};
//GlobalVariables.PokemonsInternal.Add(y);
GlobalSettings.Output = new Output();
Program p = new Program();
Thread a = new Thread(p.Start) { IsBackground = true};
//Start(); p
a.Start();
}
public MainViewModel()
{
//Console = Console.Default();
var mmu = new Mmu();
Console = new Console(
new Cpu(mmu), mmu,
new Gpu(mmu,
// TODO make palettes configurable from UI
//Colors.White,
//Colors.LightGray,
//Colors.DarkGray,
//Colors.Black),
//new Color { R = 0xB8, G = 0xC2, B = 0x66 },
//new Color { R = 0x7B, G = 0x8A, B = 0x32 },
//new Color { R = 0x43, G = 0x59, B = 0x1D },
//new Color { R = 0x13, G = 0x2C, B = 0x13 }),
Colors.GhostWhite,
Colors.LightSlateGray,
Colors.DarkSlateBlue,
Colors.Black),
new Timer(mmu),
new Controller(mmu));
Title = "GameboyEm";
OpenCommand = new ActionCommand(Open);
LoadStateCommand = new ActionCommand(LoadState);
SaveStateCommand = new ActionCommand(SaveState);
CloseCommand = new ActionCommand(Application.Current.Shutdown);
PowerOnCommand = new ActionCommand(PowerOn);
PowerOffCommand = new ActionCommand(PowerOff);
ResetCommand = new ActionCommand(Reset);
DebuggerCommand = new ActionCommand(Debugger);
}
public ExpensesViewModel(IUnityContainer container)
{
_container = container;
CreateExpenseCommand = new ActionCommand(OnCreateExpense);
GetExpenses();
}
public DbDipViewModel()
{
Corpuses = new ObservableCollection<DipCorpus>();
foreach(var corpus in CorpusesStorage.AllCorpuses())
{
Corpuses.Add(corpus);
}
AddCommand = new ActionCommand(() =>
{
StartProgress();
var editor = GenericEdit.Create(new DipCorpus
{
Name = "Новий корпус",
PinCount = 8,
CorpusWidthMm = 6
}, corpus =>
{
Corpuses.Add(corpus);
SaveCorpuses();
});
editor.ShowDialog();
CompleteProgress();
});
EditCommand = new ActionCommand<DipCorpus>(item =>
{
StartProgress();
// TODO Should copy instead of modification
var editor = GenericEdit.Create(item, corpus =>
{
SaveCorpuses();
});
editor.ShowDialog();
CompleteProgress();
});
RemoveCommand = new ActionCommand<DipCorpus>(item =>
{
StartProgress();
Corpuses.Remove(item);
SaveCorpuses();
CompleteProgress();
});
GenerateCommand = new ActionCommand<DipCorpus>(item =>
{
StartProgress();
new DipBuilder(new SwContext()).Build(item);
CompleteProgress();
});
}
//====================================================================================================
public AddBookingViewModel(IMessageBoxService mboxService, IConfigService configService,
IParentVm parent, Booking model)
{
_parent = parent;
_mboxService = mboxService;
_configService = configService;
//Get Configuration
AvailableDurations = _configService.GetAvailableDurations();
//Set Commands
SubmitCommand = new ActionCommand(OnSubmit, _=>_isFormValid);
CancelCommand = new ActionCommand(OnCancel);
//Set up the screen for Add or Display.
if (model.Id == -1)
{
Model = model;
Caption = "Add New Booking";
IsAddMode = true;
}
else
{
Model = model;
Caption = "Existing Booking";
IsAddMode = false;
}
}
/// <summary>
/// Constructeur.
/// </summary>
public Equipement_SOViewModel()
: base()
{
ManageSousTypeOuvrageCommand = new ActionCommand<object>(
obj => ManageSousTypeOuvrage(), obj => true);
this.OnViewActivated += (o, e) =>
{
if (!e.ViewParameter.Any(r => r.Key == "IsTopContainerLoaded"))
{
EventAggregator.Publish("CustomTopContainer".AsViewNavigationArgs().AddNamedParameter("HideContainer", false));
EventAggregator.Publish("TypeEquipement".AsViewNavigationArgs().AddNamedParameter("IsTopContainerLoaded", true));
}
if (!e.ViewParameter.Any(p => p.Key == "IsExpanderLoaded"))
{
EventAggregator.Publish("CustomExpander".AsViewNavigationArgs().AddNamedParameter("Title", Resources.Resource.EquipementExpanderTitle));
EventAggregator.Publish("Equipement_Expander".AsViewNavigationArgs().AddNamedParameter("IsExpanderLoaded", true).AddNamedParameter(Constants.SPECIFIC_VIEWMODEL_NAME, "Equipement_SO"));
}
};
this.OnAddedEntity += (o, e) =>
{
((EqSoutirage)this.SelectedEntity).DateControle = DateTime.Now;
((EqSoutirage)this.SelectedEntity).DateMiseEnServiceRedresseur = DateTime.Now;
};
this.OnAllServicesLoaded += (o, e) =>
{
RaisePropertyChanged(() => this.TypeRedresseurs);
RaisePropertyChanged(() => this.TypeDeversoirs);
};
}
/// <summary>
/// Constructeur par défaut
/// </summary>
public Equipement_LIViewModel()
: base()
{
NavigateLiaisonCommand = new ActionCommand<object>(
obj => NavigateToLiaison(obj), obj => true);
NavigatePortionCommand = new ActionCommand<object>(
obj => NavigateToPortion(obj), obj => true);
this.OnSaveSuccess += (o, e) =>
{
//Si on a ajouté une LIEE, on doit ajouter le lien entre les LIEE
this.RaisePropertyChanged(() => this.SelectedEntity);
};
this.OnViewActivated += (o, e) =>
{
if (!e.ViewParameter.Any(r => r.Key == "IsTopContainerLoaded"))
{
EventAggregator.Publish("CustomTopContainer".AsViewNavigationArgs().AddNamedParameter("HideContainer", false));
EventAggregator.Publish("TypeEquipement".AsViewNavigationArgs().AddNamedParameter("IsTopContainerLoaded", true));
}
if (!e.ViewParameter.Any(p => p.Key == "IsExpanderLoaded"))
{
EventAggregator.Publish("CustomExpander".AsViewNavigationArgs().AddNamedParameter("Title", Resources.Resource.EquipementExpanderTitle));
EventAggregator.Publish("Equipement_Expander".AsViewNavigationArgs().AddNamedParameter("IsExpanderLoaded", true).AddNamedParameter(Constants.SPECIFIC_VIEWMODEL_NAME, "Equipement_LI"));
}
LiaisonsCommunes = null;
};
this.OnDetailLoaded += (o, e) =>
{
Initialisation();
};
this.OnAddedEntity += (o, e) =>
{
Initialisation();
((EqEquipementService)this.service).GetListPointCommun(ListPointCommunLoaded);
};
this.OnAllServicesLoaded += (o, e) =>
{
RaisePropertyChanged(() => this.TypeLiaisons);
((EqEquipementService)this.service).GetListPointCommun(ListPointCommunLoaded);
};
this.OnSaveSuccess += (o, e) =>
{
LiaisonInterEeBeforeChange = ((EqLiaisonInterne)this.SelectedEntity).LiaisonInterEe;
RaisePropertyChanged(() => this.IsLibelleInterEE);
((EqEquipementService)this.service).GetListPointCommun(ListPointCommunLoaded);
};
this.OnDeleteSuccess += (o, e) =>
{
((EqEquipementService)this.service).GetListPointCommun(ListPointCommunLoaded);
};
}
public SelectedSecteurViewModel()
: base()
{
ValidateCommand = new ActionCommand<object>(
obj => Validate(), obj => true);
CancelCommand = new ActionCommand<object>(
obj => Cancel(), obj => true);
}
public EdataFileViewModel(EdataManagerViewModel parentVm)
{
_parentVm = parentVm;
CloseCommand = new ActionCommand((x) => ParentVm.CloseFile(this));
DetailsCommand = new ActionCommand(DetailsExecute);
AddRowCommand = new ActionCommand(AddRowExecute);
}
public ExportTourneeViewModel()
: base()
{
ExportCommand = new ActionCommand<object>(
obj => Clicked(obj));
CancelCommand = new ActionCommand<object>(
obj => Cancel(), obj => true);
}
public CreateEqEquipementTmpViewModel()
: base()
{
ValidateCommand = new ActionCommand<object>(
obj => Validate(), obj => true);
CancelCommand = new ActionCommand<object>(
obj => Cancel(), obj => true);
}
public MainViewModel()
{
ReloadTenands();
CreateTenantCommand = new ActionCommand(CreateTenant);
AddNewTenantCommand = new ActionCommand(AddNewTenant);
DeleteTenantCommand = new ActionCommand(DeleteTenant);
}
public ObjectCopyResultViewModel(List<NdfObject> results, NdfEditorMainViewModel editor)
{
NewInstances = new ObservableCollection<NdfObject>(results);
Editor = editor;
DetailsCommand = new ActionCommand(DetailsExecute);
}
public ReferenceSearchResultViewModel(List<NdfPropertyValue> results, NdfEditorMainViewModel editor)
{
Results = new ObservableCollection<NdfPropertyValue>(results);
Editor = editor;
DetailsCommand = new ActionCommand(DetailsExecute);
}
public CreateInsInstrumentViewModel()
: base()
{
ValidateCommand = new ActionCommand<object>(
obj => Validate(), obj => true);
CancelCommand = new ActionCommand<object>(
obj => Cancel(), obj => true);
}
public CreateUsrUtilisateurViewModel()
: base()
{
ValidateCommand = new ActionCommand<object>(
obj => Validate(), obj => true);
CancelCommand = new ActionCommand<object>(
obj => Cancel(), obj => true);
}
public NdfEditorMainViewModel(NdfBinary ndf)
{
NdfBinary = ndf;
InitializeNdfEditor();
SaveNdfbinCommand = new ActionCommand(SaveNdfbinExecute, () => false);
}
public ChatHistoryViewModel(Guid serverId)
{
_serverId = serverId;
FilterCommand = new ActionCommand(() => RaisePropertyChanged("Log"));
SelectedServers = serverId.ToString();
}
public MainViewModel()
{
CurrentPage = new Uri("Views/Schema.xaml", UriKind.RelativeOrAbsolute);
NavigateTo = new ActionCommand<string>(page =>
{
CurrentPage = new Uri(page, UriKind.RelativeOrAbsolute);
RaisePropertyChanged("CurrentPage");
});
}
/// <summary>
/// Constructeur par défaut
/// </summary>
public TreeViewGeoViewModel()
{
AddCommand = new ActionCommand<object>(
obj => AddTreeItem(), obj => CanAdd);
DeleteCommand = new ActionCommand<object>(
obj => DeleteTreeItem(), obj => CanDelete);
EditCommand = new ActionCommand<object>(
obj => UpdateTreeItem(), obj => CanUpdate);
}
public ProcessorViewModel()
{
BrowseInputFolderCommand = new ActionCommand(BrowseInputFolderExecuteCommand, () => true);
BrowseOutputFolderCommand = new ActionCommand(BrowseOutputFolderExecuteCommand, () => true);
ProcessCommand = new ActionCommand(ProcessImages, () =>
FilesToProcess.Count > 0 && PercentOfOriginal > 0 && !String.IsNullOrEmpty(OutputFolder));
FilesToProcess = new List<string>();
SetDefaults();
}
public CatalogShotsViewModel()
{
if (new LocalDeviceHelper().CheckNetWorkStatus())
GetCatalogShot(ShotCatalog.Popular, 1, 10);
else
base.NetworkIsInvalid();
MoreItemCommand = new ActionCommand<object>(MoreItem);
}
public ApplicationViewModel(IBlogPostRepository repository)
{
if (repository == null) throw new ArgumentNullException(nameof(repository));
this.repository = repository;
BlogPosts = GetBlogPosts(repository);
SaveCommand = new ActionCommand(SaveBlogPost);
}
private bool WasActionInvoked( object parameter )
{
var wasInvoked = false;
var command = new ActionCommand<object>( obj => wasInvoked = true );
command.Execute( parameter );
return wasInvoked;
}
public Shell()
{
InitializeComponent();
CombatCommand = new ActionCommand(OnCombat);
Presenter.Register(AppPresenters.Shell, new ContentControlPresenter(content));
DataContext = this;
}
public CredentialsViewModel()
{
LoginCommand = new ActionCommand(_ => Result = AuthenticationDialogResult.Ok);
CancelCommand = new ActionCommand(_ => Result = AuthenticationDialogResult.Cancel);
LoginValidator = PropertyValidator.For(this, x => x.Login)
.Required(Resources.LoginRequired);
PasswordValidator = PropertyValidator.For(this, x => x.Password)
.Required(Resources.PasswordRequired);
ModelValidator = new ModelValidator(LoginValidator, PasswordValidator);
ModelValidator.PropertyChanged += (s, e) =>
{
if (e.PropertyName == nameof(ModelValidator.IsValid))
{
IsValid = ModelValidator.IsValid;
}
};
}
public void ProcessCommand(IExecutionContext context, string line, ActionCommand command, ContainerInfo container)
{
ArgUtil.NotNullOrEmpty(command.Data, "value");
switch (command.Data.Trim().ToUpperInvariant())
{
case "ON":
context.EchoOnActionCommand = true;
context.Debug("Setting echo command value to 'on'");
break;
case "OFF":
context.EchoOnActionCommand = false;
context.Debug("Setting echo command value to 'off'");
break;
default:
throw new Exception($"Invalid echo command value. Possible values can be: 'on', 'off'. Current value is: '{command.Data}'.");
}
}
public ZoomBoxOverlay(ModelsEx models) : base(models)
{
this.models = models;
IsEnabled = true;
Layer = models.Display.ActiveLayer;
models.Overlay.Overlays.Add(this);
models.Display.UserInfo = "Click left to start zoombox";
if (prevRatio.HasValue)
{
curRatio = prevRatio.Value;
keepRatio = true;
}
ToggleRatioCommand = new ActionCommand(() => KeepRatio = !KeepRatio);
View = new ZoomBoxToolbar
{
DataContext = this
};
}
public void ProcessCommand(IExecutionContext context, string line, ActionCommand command, ContainerInfo container)
{
var configurationStore = HostContext.GetService <IConfigurationStore>();
var isHostedServer = configurationStore.GetSettings().IsHostedServer;
var allowUnsecureCommands = false;
bool.TryParse(Environment.GetEnvironmentVariable(Constants.Variables.Actions.AllowUnsupportedCommands), out allowUnsecureCommands);
// Apply environment from env context, env context contains job level env and action's env block
#if OS_WINDOWS
var envContext = context.ExpressionValues["env"] as DictionaryContextData;
#else
var envContext = context.ExpressionValues["env"] as CaseSensitiveDictionaryContextData;
#endif
if (!allowUnsecureCommands && envContext.ContainsKey(Constants.Variables.Actions.AllowUnsupportedCommands))
{
bool.TryParse(envContext[Constants.Variables.Actions.AllowUnsupportedCommands].ToString(), out allowUnsecureCommands);
}
// TODO: Eventually remove isHostedServer and apply this to dotcom customers as well
if (!isHostedServer && !allowUnsecureCommands)
{
throw new Exception(String.Format(Constants.Runner.UnsupportedCommandMessageDisabled, this.Command));
}
else if (!allowUnsecureCommands)
{
// Log Telemetry and let user know they shouldn't do this
var issue = new Issue()
{
Type = IssueType.Error,
Message = String.Format(Constants.Runner.UnsupportedCommandMessage, this.Command)
};
issue.Data[Constants.Runner.InternalTelemetryIssueDataKey] = Constants.Runner.UnsupportedCommand;
context.AddIssue(issue);
}
ArgUtil.NotNullOrEmpty(command.Data, "path");
context.Global.PrependPath.RemoveAll(x => string.Equals(x, command.Data, StringComparison.CurrentCulture));
context.Global.PrependPath.Add(command.Data);
}
public CalibrationBaseVM(
BusyObject busy,
IRUSDevice device,
Func <FileType, IEnumerable <IDataEntity>, Task> saveCalibrationFileAsync)
{
_device = device;
_calibrator = instantiateCalibrator();
DataProvider = _calibrator is IDataProvider
? (IDataProvider)_calibrator
: (IDataProvider)(_device = new RUSDeviceDataProviderProxy(_device));
_calibrator.RedirectAnyChangesTo(this, () => PropertyChanged, nameof(HasCalibrationBegun));
IsBusy = busy;
_fileGenerator = new CalibrationFileGenerator(device, calibrationFileType, "01");
_saveCalibrationFileAsync = saveCalibrationFileAsync;
_calibrator.PropertyChanged += (o, e) => updateModelBindings();
updateModelBindings();
StartMeasure = new ActionCommand <TMode>(startMeasureAsync,
m => canStartMeasure(m) && !IsBusy,
IsBusy, this, _calibrator);
CancelMeasure = new ActionCommand(cancelMeasureAsync);
FinishMeasure = new ActionCommand <TMode>(finishMeasureAsync,
m => canFinishMeasure(m) &&
_calibrator.State == MeasureState.WAITING_FOR_FINISH &&
(!m.IsSet || Equals(getModelsTestMode(m.Value), _calibrator.CurrentMode)),
_calibrator);
ExportMeasureResults = new ActionCommand(exportMeasureResultAsync,
() => !IsBusy && canExport,
this, _calibrator, IsBusy);
ImportMeasureResults = new ActionCommand(importMeasureResultAsync, IsBusy);
SaveCalibrationFile = new ActionCommand(saveCalibrationsAsync,
() => !IsBusy && _calibrator.CallibrationCanBeGenerated,
IsBusy, _calibrator);
CancelMeasure.CanBeExecuted = false;
Begin = new ActionCommand(beginAsync,
() => !HasCalibrationBegun && !IsBusy,
IsBusy, _calibrator);
Discard = new ActionCommand(discardAsync,
() => HasCalibrationBegun && !IsBusy,
IsBusy, _calibrator);
}
public void CommandExecute(ActionCommand command)
{
if (command.commandID == "Retrieve")
{
Retrieve();
}
else if (command.commandID == "Rope_Unroll")
{
isRopeUnrolled = true;
}
else if (command.commandID == "Rope_Cancel")
{
isRopeUnrolled = false;
targetVehicle = null;
}
else if (command.commandID == "Rope_Attach")
{
isRopeAttached = true;
}
else if (command.commandID == "Rope_Deattach")
{
isRopeAttached = false;
targetVehicle = null;
}
else if (command.commandID == "Tow_On")
{
isTowing = true;
}
else if (command.commandID == "Tow_Off")
{
isTowing = false;
}
else if (command.commandID == "Setting")
{
DestinyInternalCommand.instance.Quit_ActionCommand();
DestinyInternalCommand.instance.Game_LockGame(true, true);
UI_Canvas.gameObject.SetActive(true);
}
UpdateTowingEquipment();
}
public Scene2DTools()
{
Tools = new ObservableCollection <Scene3DViewModelLib.Scene2DButtonModel>();
InitializeComponent();
//TODO: Actions in extra new Classes incl impl!
{
string txt = "Grid On/Off";
ActionCommand cmd = new ActionCommand(action => OnGridToogle(), canExecute => true, (b) => {
OnFocus(b ? txt : null);
});
Scene2DButtonModel buttonModelGrid = new Scene2DButtonModel("pack://application:,,,/Scene3DRes;component/res/grid.png", txt, cmd, Tools.Count);
Tools.Add(buttonModelGrid);
}
{
string txt = "Camera Info On/Off";
ActionCommand cmd = new ActionCommand(action => OnCameraInfoToogle(), canExecute => true, (b) => {
OnFocus(b ? txt : null);
});
Scene2DButtonModel buttonModelGrid = new Scene2DButtonModel("pack://application:,,,/Scene3DRes;component/res/cameraInfo.png", txt, cmd, Tools.Count);
Tools.Add(buttonModelGrid);
}
{
string txt = "Show/Hide View Cube";
ActionCommand cmd = new ActionCommand(action => OnViewCubeToogle(), canExecute => true, (b) => {
OnFocus(b ? txt : null);
});
Scene2DButtonModel buttonModelGrid = new Scene2DButtonModel("pack://application:,,,/Scene3DRes;component/res/viewCube.png", txt, cmd, Tools.Count);
Tools.Add(buttonModelGrid);
}
{
string txt = "Show/Hide SkyBox";
ActionCommand cmd = new ActionCommand(action => OnViewSkyBoxToogle(), canExecute => true, (b) => {
OnFocus(b ? txt : null);
});
Scene2DButtonModel buttonModelGrid = new Scene2DButtonModel("pack://application:,,,/Scene3DRes;component/res/skybox.png", txt, cmd, Tools.Count);
Tools.Add(buttonModelGrid);
}
}
public MainWindowVm()
{
_uiDispatcher = Application.Current.Dispatcher;
base.DisplayName = Texts.MainWindow_DisplayName;
ShowTargetAssembliesCommand = new ActionCommand(x => ShowTargetAssemblies());
NewQueryCommand = new ActionCommand(x => AddQueryWorkspace());
CloseAllQueriesCommand = new ActionCommand(x => _workspaceHolder.CloseAll());
Commands.Add(new IconCommandVm(Texts.Command_NewQueryWorkspace, Images.Command_NewQueryWorkspace.ToImageSource(), NewQueryCommand));
Commands.Add(new IconCommandVm(Texts.Command_AddDll, Images.Command_AddAssembly.ToImageSource(), new ActionCommand(x => AddDll())));
RefreshToolbarMenu();
ToolbarCommands = new ReadOnlyObservableCollection <IconCommandVm>(_toolbarCommands);
Commands.CollectionChanged += delegate { RefreshToolbarMenu(); };
_workspaceHolder.CurrentChanged += delegate { RefreshToolbarMenu(); };
AddQueryWorkspace();
}
internal Task SendActionCommandAsync(ActionCommand actionCommand)
{
var utf8ByteArray = SerializeToUtf8(actionCommand);
return(Task.Run(async() =>
{
using (var client = new HttpClient())
{
var stringContent = new ByteArrayContent(utf8ByteArray);
var url = string.Concat(Network.IP, ":", Network.PORT);
try
{
await client.PostAsync(url, stringContent);
}
catch (Exception)
{
// Fire and forget
}
}
}));
}
public CustomDipViewModel()
{
PinCount = 8;
CorpusWidthMm = 6.0;
GenerateCommand = new ActionCommand(async() =>
{
StartProgress();
// Do generation
var model = new DipCorpus
{
Name = Name,
PinCount = PinCount,
CorpusWidthMm = CorpusWidthMm
};
await Task.Run(() => new DipBuilder(new SwContext()).Build(model));
CompleteProgress();
});
}
public ShotDetailViewModel(int shotId)
{
try
{
if (new LocalDeviceHelper().CheckNetWorkStatus())
{
GetShotDetail(shotId);
}
else
{
base.NetworkIsInvalid();
}
this.ShotId = shotId;
MoreItemCommand = new ActionCommand <object>(MoreItem);
}
catch (Exception se)
{
new UmengRegisterEventHelper().RegisterUmengEventByType(AnalysicEventType.AppExceptionReport, "", se);
}
}
public Module()
{
_navigateToExampleCommand = new ActionCommand <Example>(example =>
{
var lastExamplePage = CurrentExample != null ? CurrentExample.Page as ExampleAppPage : null;
CurrentExample = example;
Navigator.Instance.Navigate(example);
Navigator.Instance.Push(example);
if (lastExamplePage != null)
{
// Required to release memory on example switch
lastExamplePage.ViewModel = null;
}
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
});
}
protected override void InternalExecute(ICommandAdapter adapter)
{
if (adapter.IsWinAdapter())
{
SaveAndCloseAction(adapter);
}
else
{
if (SaveAndCloseActionAvailable(adapter))
{
SaveAndCloseAction(adapter);
}
else
{
var actionCommand = new ActionCommand();
actionCommand.Parameters.MainParameter = new MainParameter("OK");
actionCommand.Parameters.ExtraParameter = new MainParameter();
actionCommand.Execute(adapter);
}
}
}
/// ########################### Konstruktor ###########################################
public MaschinenkaufdatenViewModel(Maschinenkaufdaten Maschinenkaufdaten = null)
{
/// ########################### Befehle Verknüpfen ###########################################
Maschinenkauftabeldoubleclick = new ActionCommand(MaschinenkauftabeldoubleclickMethod);
Maschinenkauftabelclick = new ActionCommand(MaschinenkauftabelclickMethod);
PressEnterKey = new ActionCommand(PressEnterKeyMethod);
AddCommand = new ActionCommand(Add);
SaveCommand = new ActionCommand(Save);
DeleteCommand = new ActionCommand(Delete);
DataService client = new DataService();
Maschinenkauf = client.GetAllMaschinenkaufe();
Maschinenart = client.GetAllMaschinenarten();
MaschinenartenIDs = new ObservableCollection <int>(client.GetAllMaschinenarten().Select(p => p.Maschinenart_ID));
MaschinenartenBezeichnung = new ObservableCollection <string>(client.GetAllMaschinenarten().Select(p => p.Maschinenartbezeichnung));
client.Close();
}
public MainViewModel()
{
rootTreeItem1 = new TreeItem();
rootTreeItem2 = new TreeItem();
// Pfad bei Bedarf anpassen
var path = Directory.GetParent(Environment.CurrentDirectory).Parent.Parent.Parent.FullName;
FillTree(Tree1, path, 0);
FillTree(Tree2, path, 0);
ExpandAllCommand = new ActionCommand(() => Tree1.ExpandOrCollapseAll(true));
CollapseAllCommand = new ActionCommand(() => Tree1.ExpandOrCollapseAll(false));
OpenAppXamlCommand = new ActionCommand(OpenAppXaml);
DragDropControllerTV1 = new DragDropController()
{
CanDrag = CanDragTV1, CanDrop = CanDropTV1, Drop = DropTV1
};
}
public override bool CanResolve(ActionCommand cmd)
{
var center = cmd.Owner.Target.GetPositionP3;
for (int i = 0; i < _radius; i++)
{
var pos = center;
pos[_axisDirection] += i;
var cell = CombatArenaMap.Current.Get(pos);
if (cell.Unit == null)
{
continue;
}
if (_checkRequirements && !cmd.Action.Config.CanEffect(cmd.Action, cmd.Owner, cell.Unit))
{
continue;
}
cmd.CheckHit(_targetDefense, _bonusStat, cell.Unit);
}
return(true);
}
public SettingsViewModel(ISettingCollection settingCollection)
{
this.settingCollection = settingCollection;
this.settingCollection.Load();
ModifierKeys = Enum.GetValues(typeof(ModifierKeys)).Cast <ModifierKeys>().ToList();
Keys = Enum.GetValues(typeof(Keys)).Cast <Keys>().ToList();
Enum.TryParse(this.settingCollection.Settings.FirstOrDefault(x => x.Key == "Modifier1").Value, out ModifierKeys modifierKey1);
Modifier1 = modifierKey1;
Enum.TryParse(this.settingCollection.Settings.FirstOrDefault(x => x.Key == "Modifier2").Value, out ModifierKeys modifierKey2);
Modifier2 = modifierKey2;
Enum.TryParse(this.settingCollection.Settings.FirstOrDefault(x => x.Key == "Key").Value, out Keys key);
Key = key;
SaveCommand = new ActionCommand(x =>
{
this.settingCollection.Save(Modifier1, Modifier2, Key);
MessageBox.Show("Settings saved!");
});
}
protected MediaPlaybackViewModel(HistoryService historyService, IMediaService mediaService, VlcService mediaPlayerService)
{
_historyService = historyService;
_mediaService = mediaService;
_mediaService.StatusChanged += PlayerStateChanged;
_vlcPlayerService = mediaPlayerService;
_displayAlwaysOnRequest = new DisplayRequest();
_sliderPositionTimer = new DispatcherTimer();
_sliderPositionTimer.Tick += FirePositionUpdate;
_sliderPositionTimer.Interval = TimeSpan.FromMilliseconds(16);
_skipAhead = new ActionCommand(() => _mediaService.SkipAhead());
_skipBack = new ActionCommand(() => _mediaService.SkipBack());
_playNext = new PlayNextCommand();
_playPrevious = new PlayPreviousCommand();
_playOrPause = new PlayPauseCommand();
_goBackCommand = new StopVideoCommand();
}
protected TwitchAccountViewModel(ITwitchAuthentication twitchAuthentication,
ITwitchConnection twitchConnection,
AuthenticationType authType, object icon, object label, object toolTip, UserControl content)
: base(icon, label, toolTip, content)
{
AuthType = authType;
_twitchAuthentication = twitchAuthentication;
_twitchConnection = twitchConnection;
ConnectCommand = new ActionCommand(Connect);
DisconnectCommand = new ActionCommand(Disconnect);
GenerateTokenCommand = new ActionCommand(GenerateToken);
ManualEntryCommand = new ActionCommand(SwitchToManualEntry);
if (!_twitchAuthentication.Credentials.ContainsKey(AuthType))
{
_twitchAuthentication.Credentials[AuthType] = new TwitchCredentials
{
AuthType = authType
};
}
}
public ViewModel()
{
CheckCommand = new ActionCommand(Validate);
Validators.Add(new Validator()
{
PropertyName = nameof(Minimum), ErrorMessage = "Minimum muss >= 0 sein", CheckForError = () => Minimum < 0
});
Validators.Add(new Validator()
{
PropertyName = nameof(Maximum), ErrorMessage = "Maximum muss > 0 sein", CheckForError = () => Maximum <= 0
});
Validators.Add(new Validator()
{
PropertyName = nameof(Maximum), ErrorMessage = "Minimum muss kleiner als Maximum sein", CheckForError = () => Minimum >= Maximum
});
Validators.Add(new Validator()
{
PropertyName = nameof(Maximum), ErrorMessage = "Maximum muss durch 10 teilbar sein", CheckForError = () => (Maximum % 10) != 0
});
//Validators.Add(new Validator() { PropertyName = "Name", ErrorMessage = "Name darf nicht leer sein", CheckForError = () => string.IsNullOrEmpty(Name) });
}
public MonitoringViewModel()
{
Numbers = new ObservableCollection <int>();
Numbers.Add(2);
Numbers.Add(5);
Numbers.Add(10);
sets = AppSetting.loadSettings();
//
myDisp = Dispatcher.CurrentDispatcher;
lstFiles = new ObservableCollection <Photo>();
//
this.startWatch();
//
actionCmd = new ActionCommand(changePath);
this.teest = sets.WorkFolder;
}
// treeview managers
private void AddCommand(EventCommand esc)
{
TreeNode node = esc.Node;
if (esc.QueueTrigger || esc.Locked)
{
if (esc.Queue == null)
{
return;
}
List <ActionCommand> queue = esc.Queue.Commands;
for (int i = 0; queue != null && i < queue.Count; i++)
{
ActionCommand asc = queue[i];
TreeNode child = asc.Node;
node.Nodes.Add(child);
}
}
// Add command
this.treeView.Nodes.Add(node);
}
public ModuleData(string moduleName, string moduleFolderName)
{
ModuleName = moduleName;
ModuleFolderName = moduleFolderName;
AddTemplateControlVisible = false;
Templates = new ObservableImmutableList <TemplateEditorData>();
KeyList = new ObservableImmutableList <KeywordData>();
BindingOperations.EnableCollectionSynchronization(Templates, TemplatesLock);
BindingOperations.EnableCollectionSynchronization(KeyList, KeyListLock);
LoadKeywords = new ActionCommand(() => { FileCommands.Load.LoadUserKeywords(this); });
SaveSettingsCommand = new ActionCommand(() =>
{
FileCommands.Save.SaveModuleSettings(this);
AppController.Main?.SaveAppSettings();
});
DefaultSettingsCommand = new TaskCommand(RevertSettingsToDefault, null, "Reset Settings?", "Revert settings to default?", "Changes will be lost.");
}
public MainWindowViewModel()
{
ToggleArgumentCommand =
new ActionCommand
(
x => true,
(x) =>
{
;
}
);
FunctionOneCommand =
new ActionCommand
(
x => true,
(x) =>
{
;
}
);
}
public PlayerDetailViewModel(PlayerInTeam playerInTeamViewModel)
{
Model = new PlayerInTeamViewModel(playerInTeamViewModel);
CurrentChartXPlayerStatistic = ChartXPlayerStatistic.Point;
SetPointStatistic = new ActionCommand(() => CurrentChartXPlayerStatistic = ChartXPlayerStatistic.Point);
SetReboundStatistic = new ActionCommand(() => CurrentChartXPlayerStatistic = ChartXPlayerStatistic.Rebound);
SetAssistsStatistic = new ActionCommand(() => CurrentChartXPlayerStatistic = ChartXPlayerStatistic.Assists);
SetStealsStatistic = new ActionCommand(() => CurrentChartXPlayerStatistic = ChartXPlayerStatistic.Steals);
SetBlocksStatistic = new ActionCommand(() => CurrentChartXPlayerStatistic = ChartXPlayerStatistic.Blocks);
Search = new ActionCommand(() =>
{
UpdatePlayerStatisticsInDateRange();
PropertyChanged.Invoke(this, new PropertyChangedEventArgs(nameof(ChartPoints)));
});
playerStatistics = new ObservableCollection <PlayerStatistics>(Model.Model.Player.PlayerStatistics.ToList());
BiginingIntervalDate = DateTime.Now.AddYears(-10);
EndIntervalDate = DateTime.Now;
UpdatePlayerStatisticsInDateRange();
}
public TreeEditorViewModel(IEditorEnvironment editorEnvironment) : base(editorEnvironment)
{
RootNodes = new ReadOnlyObservableCollection <ITreeNode>(_rootNodes);
// These commands are used for keyboard shortcuts
DeleteNodeCommand = new ActionCommand(DeleteSelectedNode, CanDeletedSelectedNode);
CutNodeCommand = new ActionCommand(CutNode, CanCutNode);
CopyNodeCommand = new ActionCommand(CopyNode, CanCopyNode);
PasteNodeCommand = new ActionCommand(PasteNode, CanPasteNode);
DuplicateNodeCommand = new ActionCommand(DuplicateNode, CanDuplicateNode);
UndoCommand = new ActionCommand(Undo, CanUndo);
RedoCommand = new ActionCommand(Redo, CanRedo);
ActiveContextMenuCommands = new ReadOnlyObservableCollection <ContextMenuCommand>(_activeContextMenuCommands);
// Group catalog items by category
var view = CollectionViewSource.GetDefaultView(CatalogItems);
var groupDescription = new PropertyGroupDescription(nameof(NodeCatalogItem.Category));
view.GroupDescriptions.Add(groupDescription);
}
public UsingDonutChartExampleViewModel()
{
_donutModels = new ObservableCollection <IPieSegmentViewModel>
{
new DonutSegmentViewModel {
Value = 48, Name = "Rent", Stroke = ToShade(Colors.Orange, 0.8), Fill = ToGradient(Colors.Orange), StrokeThickness = 2
},
new DonutSegmentViewModel {
Value = 19, Name = "Food", Stroke = ToShade(Colors.Green, 0.8), Fill = ToGradient(Colors.Green), StrokeThickness = 2
},
new DonutSegmentViewModel {
Value = 9, Name = "Utilities", Stroke = ToShade(Colors.DodgerBlue, 0.8), Fill = ToGradient(Colors.DodgerBlue), StrokeThickness = 2
},
new DonutSegmentViewModel {
Value = 9, Name = "Fun", Stroke = ToShade(Colors.Gray, 0.8), Fill = ToGradient(Colors.Gray), StrokeThickness = 2
},
new DonutSegmentViewModel {
Value = 10, Name = "Clothes", Stroke = ToShade(Colors.Firebrick, 0.8), Fill = ToGradient(Colors.Firebrick), StrokeThickness = 2
},
new DonutSegmentViewModel {
Value = 5, Name = "Phone", Stroke = ToShade(Colors.DarkSalmon, 0.8), Fill = ToGradient(Colors.DarkSalmon), StrokeThickness = 2
}
};
AddNewItemCommand = new ActionCommand(() =>
{
_donutModels.Add(new DonutSegmentViewModel
{
Value = NewSegmentValue.ToDouble(),
Name = NewSegmentText,
Fill = ToGradient(((SolidColorBrush)NewSegmentBrush.Brush).Color),
Stroke = ToShade(((SolidColorBrush)NewSegmentBrush.Brush).Color, 0.8)
});
}, () =>
{
return(!NewSegmentText.IsNullOrEmpty() && (!NewSegmentValue.IsNullOrEmpty() && NewSegmentValue.ToDouble() > 0) && NewSegmentBrush != null);
});
SegmentSelectionCommand = new ActionCommand <NotifyCollectionChangedEventArgs>(OnSegmentSelectionExecute);
}
public ServerMonitorChatViewModel(ILog log, ServerInfo serverInfo, IEventAggregator eventAggregator)
{
_log = log;
_serverId = serverInfo.Id;
_eventAggregator = eventAggregator;
AutoScroll = true;
EnableChat = true;
_chatHelper = new ChatHelper(_log, _serverId);
_eventAggregator.GetEvent <BEMessageEvent <BEChatMessage> >()
.Subscribe(BeServerChatMessageHandler, ThreadOption.UIThread);
_eventAggregator.GetEvent <BEMessageEvent <BEAdminLogMessage> >()
.Subscribe(_beServer_PlayerLog, ThreadOption.UIThread);
_eventAggregator.GetEvent <BEMessageEvent <BEPlayerLogMessage> >()
.Subscribe(_beServer_PlayerLog, ThreadOption.UIThread);
_eventAggregator.GetEvent <BEMessageEvent <BEBanLogMessage> >()
.Subscribe(_beServer_PlayerLog, ThreadOption.UIThread);
_eventAggregator.GetEvent <BEMessageEvent <BEItemsMessage <Player> > >()
.Subscribe(_beServer_PlayerHandler);
var global = new Player(-1, null, 0, 0, null, "GLOBAL", Player.PlayerState.Ingame);
Players = new List <Player> {
global
};
SelectedPlayer = global;
ShowHistoryCommand = new ActionCommand(() =>
{
var model = new ChatHistoryViewModel(_serverId);
model.StartDate = DateTime.UtcNow.UtcToLocalFromSettings().AddHours(-5);
var wnd = new ChatHistory(model);
wnd.Show();
wnd.Activate();
});
}
public GameSettingsViewModel(
GameStateModel gameState,
INavigationService navigationService)
{
_gameState = gameState;
_navigationService = navigationService;
_subscriptions = new CompositeDisposable();
SaveCommand = new ActionCommand(
execute: () =>
{
_gameState.Settings.Value = new GameSettingsModel(
_dominoSetType,
_memoryInterval);
_navigationService.NavigateTo(null);
},
canExecute: Observable.CombineLatest(
_gameState.Settings,
this.ObserveProperty(x => x.DominoSetType),
this.ObserveProperty(x => x.MemoryInterval),
navigationService.CanNavigateTo,
(settings, dominoSetType, memoryInterval, canNavigateTo) =>
canNavigateTo &&
((dominoSetType != settings.DominoSetType) ||
(memoryInterval != settings.MemoryInterval))))
.DisposeWith(_subscriptions);
UndoCommand = new ActionCommand(
execute: () =>
{
ReloadSettings();
_navigationService.NavigateTo(null);
})
.DisposeWith(_subscriptions);
ReloadSettings();
}
/// <summary>
/// Constructs a new Window View Model
/// </summary>
/// <param name="window">The window itself</param>
public WindowViewModel(Window window)
{
_window = window;
// Initialize Commands
MinimizeCommand = new ActionCommand(() => _window.WindowState = WindowState.Minimized);
MaximizeCommand = new ActionCommand(() => _window.WindowState ^= WindowState.Maximized);
CloseWindowCommand = new ActionCommand(() => _window.Close());
SystemMenuCommand = new ActionCommand(() => SystemCommands.ShowSystemMenu(_window, GetMousePosition()));
// Fix the Window Resize Issue
var _resizer = new WindowResizer(_window);
// Listen out for Window events
_window.StateChanged += (ss, ee) =>
{
OnGroupOfPropertyChanged(nameof(ResizeBorderThickness),
nameof(OuterBorderPaddingThickness),
nameof(WindowCornerRadius),
nameof(TitleBarCornerRadius));
};
}