public ChatViewModel()
{
TextItems = new AsyncObservableCollection<Chat>();
Message = "";
Commands.SendMessageCommand.CanExecute += (sender, e) => e.CanExecute = true;
Commands.SendMessageCommand.Executed += SendMessageCommand_OnExecuted;
}
public EnfusePluginViewModel(Window window)
{
if (!IsInDesignMode)
{
window.Closing += window_Closing;
ServiceProvider.FileTransfered += ServiceProvider_FileTransfered;
ServiceProvider.WindowsManager.Event += WindowsManager_Event;
SetEnabled();
ResetCommand = new RelayCommand(SetDefault);
PreviewCommand = new RelayCommand(Preview);
GenerateCommand = new RelayCommand(Generate);
StopCommand=new RelayCommand(Stop);
ConfPluginCommand = new RelayCommand(ConfPlugin);
InitCommands();
Output = new AsyncObservableCollection<string>();
LoadData();
_pathtoalign = Path.Combine(Settings.ApplicationFolder, "Tools", "align_image_stack.exe");
var hugin = @"c:\Program Files (x86)\Hugin\bin\align_image_stack.exe";
// use hugin installation
if (File.Exists(hugin))
{
_pathtoalign = hugin;
OnProgressChange("Hugin installed using align_image_stack.exe");
}
else
{
OnProgressChange("Hugin not installed. Instal x86 version for betteer image align performance");
}
_pathtoenfuse = Path.Combine(Settings.ApplicationFolder, "Tools", "x64", "enfuse.exe");
}
}
public BaseCameraDevice()
{
IsChecked = true;
AdvancedProperties = new AsyncObservableCollection<PropertyValue<long>>();
Properties = new AsyncObservableCollection<PropertyValue<long>>();
Capabilities = new List<CapabilityEnum>();
}
public DownloadManagerViewModel()
{
_downloadsSemaphore = new FifoSemaphore(Properties.Settings.Default.MaxParallelDownloads);
var olderDownloads = new List<DownloadViewModel>();
ServiceLocator.Instance.GetService<ILibraryManager>().UpdateScrapersList(ScraperLoader.Instance.AllScrapers);
foreach (DownloadedChapterInfo chapterInfo in ServiceLocator.Instance.GetService<ILibraryManager>().GetDownloads())
{
var downloadViewModel = new DownloadViewModel(chapterInfo, _downloadsSemaphore);
downloadViewModel.RemoveFromCollection += DownloadViewModel_RemoveFromCollection;
downloadViewModel.DownloadStarted += DownloadViewModel_DownloadStarted;
olderDownloads.Add(downloadViewModel);
}
Downloads = new AsyncObservableCollection<DownloadViewModel>(olderDownloads);
_downloadsCollectionView = (ListCollectionView) CollectionViewSource.GetDefaultView(Downloads);
_downloadsCollectionView.CustomSort = new DownloadAgeComparer();
// init filter
SelectedTabIndex = Properties.Settings.Default.SelectedDownloadsTab;
}
private void CopyFiles(object o)
{
AsyncObservableCollection<FileItem> items = o as AsyncObservableCollection<FileItem>;
items = new AsyncObservableCollection<FileItem>(items.Where(file => file.IsChecked));
dlg.MaxValue = items.Count;
int i = 0;
foreach (var fileItem in items)
{
dlg.Progress = i;
dlg.ImageSource = fileItem.Thumbnail;
dlg.Label = Path.GetFileName(fileItem.FileName);
if (File.Exists(fileItem.FileName))
{
try
{
File.Copy(fileItem.FileName, Path.Combine(destfolder, Path.GetFileName(fileItem.FileName)), true);
}
catch (Exception exception)
{
Log.Error("ErrorCopy file", exception);
}
}
//Thread.Sleep(100);
i++;
}
dlg.Hide();
}
static TranslationManager()
{
AvailableLangs = new AsyncObservableCollection<TranslationLangDesc>();
try
{
_path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string[] files = Directory.GetFiles(Path.Combine(_path, "Languages"));
foreach (string file in files)
{
try
{
CultureInfo cult = CultureInfo.GetCultureInfo(Path.GetFileNameWithoutExtension(file).Replace('_','-'));
AvailableLangs.Add(new TranslationLangDesc()
{
Value = Path.GetFileNameWithoutExtension(file),
Name = cult.EnglishName + " - " + cult.NativeName
});
}
catch (Exception exception)
{
Log.Error("Error loading language", exception);
}
}
}
catch (Exception)
{
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SocialIntelligence"/> class.
/// </summary>
/// <param name="coreIntelligence">The core intelligence.</param>
public SocialIntelligence(CoreIntelligence coreIntelligence)
: base(coreIntelligence)
{
_networks = new AsyncObservableCollection<NetworkProvider>();
try
{
CoreIntelligence.RepositoryIntelligence.RegisterTable(typeof(System_Social_User2Protocol), 3);
CoreIntelligence.RepositoryIntelligence.RegisterTable(typeof(System_Social_ContactContainer), 2);
CoreIntelligence.RepositoryIntelligence.RegisterTable(typeof(System_Social_ContactContainer2ContactProvider), 2);
CoreIntelligence.RepositoryIntelligence.RegisterTable(typeof(TableModels.System_Social_ContactAttribute), 3);
User2Protocol = (Table<System_Social_User2Protocol>)CoreIntelligence.RepositoryIntelligence.LoadTable(typeof(System_Social_User2Protocol));
ContactContainer = (Table<System_Social_ContactContainer>)CoreIntelligence.RepositoryIntelligence.LoadTable(typeof(System_Social_ContactContainer));
ContactContainer2ContactProvider = (Table<System_Social_ContactContainer2ContactProvider>)CoreIntelligence.RepositoryIntelligence.LoadTable(typeof(System_Social_ContactContainer2ContactProvider));
try
{
if (User2Protocol.Count() == 0)
{
System_Social_User2Protocol usr2prot = new System_Social_User2Protocol();
usr2prot.NetworkName = "XfireProtocolES";
usr2prot.User = "******";
User2Protocol.InsertOnSubmit(usr2prot);
CoreIntelligence.RepositoryIntelligence.SubmitChanges();
}
}
catch (Exception)
{
}
}
catch (Exception) { }
loadContacts();
}
public UserMangementViewModel()
{
if (IsInDesignMode)
return;
Users = new AsyncObservableCollection<User>();
InitializeMessageHandlers();
}
public Loop()
{
Name = "loop";
Description = "execute a subset of commands for loopcount";
DefaultValue = "loop loopcount=\"10\"";
Commands = new AsyncObservableCollection<IScriptCommand>();
}
public GenMovieViewModel(Window window)
{
_window = window;
_window.Closed += _window_Closed;
StartCommand = new RelayCommand(Start);
StopCommand = new RelayCommand(Stop);
PlayVideoCommand = new RelayCommand(PlayVideo);
BrowseFileCommand = new RelayCommand(BrowseFile);
_backgroundWorker.DoWork += _backgroundWorker_DoWork;
_backgroundWorker.RunWorkerCompleted += _backgroundWorker_RunWorkerCompleted;
_backgroundWorker.WorkerSupportsCancellation = true;
TotalImages = ServiceProvider.Settings.DefaultSession.Files.Count;
MaxValue = TotalImages;
VideoTypes = new ObservableCollection<VideoType>
{
new VideoType("4K 16:9", 3840, 2160),
new VideoType("HD 1080 16:9", 1920, 1080),
new VideoType("UXGA 4:3", 1600, 1200),
new VideoType("HD 720 16:9", 1280, 720),
new VideoType("Super VGA 4:3", 800, 600),
};
VideoType = VideoTypes[0];
OutPutFile = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyVideos),
ServiceProvider.Settings.DefaultSession.Name + ".mp4");
OutPut = new AsyncObservableCollection<string>();
Fps = 15;
}
public StaticHelper()
{
SystemMessage = "";
_timer.Elapsed += _timer_Elapsed;
_timer.Start();
Messages = new AsyncObservableCollection<string>();
}
public IfCommand()
{
Name = "if";
Description = "if condition to run a set of scripts";
DefaultValue = "if condition=\"${variable}==value\" ";
Commands = new AsyncObservableCollection<IScriptCommand>();
}
public XfireNetworkProvider(EasySocial.FrameWork.Intelligence.CoreIntelligence intelligence)
: base(intelligence)
{
_encodingInstance = Encoding.ASCII;
Contacts = new AsyncObservableCollection<EasySocial.FrameWork.Networking.NetworkProviders.ContactProvider>();
Intelligence = intelligence;
Name = "XfireProtocolProviderES";
}
public PluginManager()
{
Plugins = new AsyncObservableCollection<IPlugin>();
ExportPlugins = new AsyncObservableCollection<IExportPlugin>();
ToolPlugins = new AsyncObservableCollection<IToolPlugin>();
MainWindowPlugins = new AsyncObservableCollection<IMainWindowPlugin>();
AvaiablePlugins = new AsyncObservableCollection<PluginInfo>();
}
// -----------------------------------------------------------------------------------
internal void Init(MainWindow main)
{
View = main;
MessageList = new AsyncObservableCollection<LogMessage>();
AttachEvents();
DoBinding();
}
public BraketingClass()
{
IsBusy = false;
ExposureValues = new AsyncObservableCollection<string>();
ShutterValues = new AsyncObservableCollection<string>();
PresetValues = new AsyncObservableCollection<string>();
Mode = 0;
}
public PluginCondition()
{
OperatorList = new AsyncObservableCollection<string>() {"AND", "OR"};
ConditionList = new AsyncObservableCollection<string>() { ">=","<=","!=","=","<",">","%"};
ValueList = new AsyncObservableCollection<string>();
Operator = "AND";
Condition = "=";
}
public AutoExportPluginConfig()
{
ConfigData = new ValuePairEnumerator();
ConfigDataCollection = new ObservableCollection<ValuePairEnumerator>();
Conditions = new AsyncObservableCollection<PluginCondition>();
IsError = false;
IsRedy = true;
RunAfterTransfer = true;
}
public HandViewModel()
{
CardCollection = new AsyncObservableCollection<CardViewModel>();
ChipCollection = new AsyncObservableCollection<ChipViewModel>();
InsuranceChipCollection = new AsyncObservableCollection<ChipViewModel>();
ActiveHand = false;
HandOpacity = 0;
HandInPlay = true;
}
public AddFaceViewModel()
{
_cameraHandler = new CameraHandler();
PreviewImages = new AsyncObservableCollection<PreviewImage>();
if (IsInDesignMode)
{
PreviewHeaderVisible = true;
}
}
private void InitializeMessageHandlers()
{
Messenger.Default.Register<TabSelectionChangedMessage>(this,
(message) =>
{
if (message.Index == 1)
{
Faces = new AsyncObservableCollection<Face>(RecognitionData.AllFaces);
}
});
}
public PluginManager()
{
Plugins = new AsyncObservableCollection<IPlugin>();
ExportPlugins = new AsyncObservableCollection<IExportPlugin>();
ToolPlugins = new AsyncObservableCollection<IToolPlugin>();
MainWindowPlugins = new AsyncObservableCollection<IMainWindowPlugin>();
AvaiablePlugins = new AsyncObservableCollection<PluginInfo>();
AutoExportPlugins = new AsyncObservableCollection<IAutoExportPlugin>();
ImageTransformPlugins = new AsyncObservableCollection<IImageTransformPlugin>();
PanelPlugins = new AsyncObservableCollection<IPanelPlugin>();
}
public CameraPropertyWnd()
{
AvailableKeys = new AsyncObservableCollection<string>();
InitializeComponent();
foreach (string key in Enum.GetNames(typeof(Key)))
{
AvailableKeys.Add(key);
}
PhotoSessionNames = new AsyncObservableCollection<string>();
CameraPresets = new AsyncObservableCollection<string>();
}
public PlayerViewModel()
{
HandCollection = new AsyncObservableCollection<HandViewModel>();
HandViewModel NewHand = new HandViewModel(0, 0, 1, 1);
HandCollection.Add(NewHand);
ActivePlayer = false;
PlayerPlaceHolder = @"/BlackJackSL;component/Images/Player" + PlayerId + "PlaceHolder.png";
SetPlayerPositions();
IsInPlay();
Commands.InsuranceCommand.CanExecute += (sender, e) => e.CanExecute = ActiveInsurance;
Commands.InsuranceCommand.Executed += InsuranceCommand_OnExecuted;
}
public DownloadManagerMV()
{
this.cancelItem = new CancelDownloadCommand(this);
this.pauseItem = new PauseDownloadCommand(this);
this.addItem = new AddItemCommand(this);
p_listeDownloadInfos = new AsyncObservableCollection<DownloadInfo>();
//p_listeDownloadInfos.CollectionChanged += OnDownloadInfosListeChanged;
p_listeMessages = new AsyncObservableCollection<Messages>();
SetFormatPriority();
p_nbrSegmentActuallyRunning = 0;
}
public HandViewModel(int handXPos, int handYPos, int handZPos, int handId)
{
HandId = handId;
HandXPos = handXPos;
HandYPos = handYPos;
HandZPos = handZPos;
CardCollection = new AsyncObservableCollection<CardViewModel>();
ChipCollection = new AsyncObservableCollection<ChipViewModel>();
InsuranceChipCollection = new AsyncObservableCollection<ChipViewModel>();
ActiveHand = false;
HandOpacity = 0;
HandInPlay = true;
}
public Cache()
{
_cachedItems = new List<Result>();
_results = new AsyncObservableCollection<Result>();
// load start menu items
//LoadStartMenu(Environment.GetFolderPath(Environment.SpecialFolder.StartMenu));
LoadStartMenu(@"C:\\ProgramData\\Microsoft\\Windows\\Start Menu\\Programs");
//LoadStartMenu(Environment.GetEnvironmentVariable("ALLUSERSPROFILE") + @"\Start Menu");
//LoadStartMenu(@"c:\Work");
// A default hint. Not really necessary but can be handy during testing.
//_hint = "Calc";
}
public ApplicationWorker(AccountsSettingsModel accountsSettings,
EventBus eventBus,
OutgoingMailServiceResolver serviceResolver,
AsyncObservableCollection<EmailGroupModel> emailGroupList,
ApplicationSettingsModel appSettings,
IMailStorage mailStorage)
{
_accountsSettings = accountsSettings;
_eventBus = eventBus;
_serviceResolver = serviceResolver;
_emailGroupList = emailGroupList;
_appSettings = appSettings;
_mailStorage = mailStorage;
}
public EntityViewModel(IEntity entity)
{
this.Entity = entity;
SubEntities = new AsyncObservableCollection<EntityViewModel>();
foreach ( var e in entity.SubEntities )
{
SubEntities.Add(EVMFactory.CreateEntity(e));
}
entity.OnEntityAdded += new EventHandler<EntityEventArgs>(entity_OnEntityAdded);
entity.OnEntityRemoved += new EventHandler<EntityEventArgs>(entity_OnEntityRemoved);
}
public MailListWindow(EventBus eventBus, AsyncObservableCollection<EmailGroupModel> emailGroupList, ApplicationSettingsModel appSettings)
{
_eventBus = eventBus;
_emailGroupListModel = emailGroupList;
_appSettings = appSettings;
var screen = Screen.FromHandle(new WindowInteropHelper(this).Handle).WorkingArea;
_defaultWindowRect = new Rect(screen.Width - DefaultWidth, 0, DefaultWidth, screen.Height);
InitializeComponent();
SetWindowRect();
Closing += OnClosing;
_emailGroupListModel.CollectionChanged += EmailGroupListModelOnCollectionChanged;
}
private void LoadData()
{
Tags1 =
new AsyncObservableCollection <TagItem>(
ServiceProvider.Settings.DefaultSession.Tags.Where(x => x.Tag1Checked));
Tags2 =
new AsyncObservableCollection <TagItem>(
ServiceProvider.Settings.DefaultSession.Tags.Where(x => x.Tag2Checked));
Tags3 =
new AsyncObservableCollection <TagItem>(
ServiceProvider.Settings.DefaultSession.Tags.Where(x => x.Tag3Checked));
Tags4 =
new AsyncObservableCollection <TagItem>(
ServiceProvider.Settings.DefaultSession.Tags.Where(x => x.Tag4Checked));
}
public ImageHistoryVM(IProfileService profileService) : base(profileService)
{
Title = "LblHFRHistory";
if (System.Windows.Application.Current != null)
{
ImageGeometry = (System.Windows.Media.GeometryGroup)System.Windows.Application.Current.Resources["HFRHistorySVG"];
}
_nextStatHistoryId = 0;
LimitedImageHistoryStack = new AsyncObservableLimitedSizedStack <ImageHistoryPoint>(100);
AutoFocusPoints = new AsyncObservableCollection <ImageHistoryPoint>();
PlotClearCommand = new RelayCommand((object o) => PlotClear());
}
protected override void OnDesignMode()
{
base.OnDesignMode();
CompanyBranches = new AsyncObservableCollection <Branch>
{
new Branch
{
Name = "Branch 1",
CompanyName = "Company",
CityName = "City",
CountryName = "Country",
EmployeeCount = 12
}
};
}
public BitmapFile()
{
IsLoaded = false;
RawCodecNeeded = false;
Metadata = new AsyncObservableCollection <DictionaryItem>();
//Metadata.Add(new DictionaryItem() {Name = "Exposure mode"});
//Metadata.Add(new DictionaryItem() {Name = "Exposure program"});
//Metadata.Add(new DictionaryItem() {Name = "Exposure time"});
//Metadata.Add(new DictionaryItem() {Name = "F number"});
//Metadata.Add(new DictionaryItem() {Name = "Lens focal length"});
//Metadata.Add(new DictionaryItem() {Name = "ISO speed rating"});
//Metadata.Add(new DictionaryItem() {Name = "Metering mode"});
//Metadata.Add(new DictionaryItem() {Name = "White balance"});
//Metadata.Add(new DictionaryItem() {Name = "Exposure bias"});
}
/// <summary>
/// Return items with i series
/// </summary>
/// <returns>Empty list if no item was found</returns>
public AsyncObservableCollection <FileItem> GetSeries(int i)
{
lock (_locker)
{
AsyncObservableCollection <FileItem> list = new AsyncObservableCollection <FileItem>();
foreach (FileItem fileItem in Files)
{
if (fileItem.Series == i && fileItem.Visible)
{
list.Add(fileItem);
}
}
return(list);
}
}
private void GetChatrooms(RoomList chatrooms)
{
joinableRooms = new AsyncObservableCollection <Room>();
foreach (string room in chatrooms.chatrooms)
{
string roomName = room.Remove(0, 10);
Room newRoom = new Room {
name = roomName
};
if (!rooms.Contains(newRoom))
{
joinableRooms.Add(newRoom);
}
}
}
protected override async Task OnInitialization()
{
await base.OnInitialization();
Tables = AsyncObservableCollection <SqlTableViewModel> .Create();
_pluralizationServices = PluralizationService.CreateService(CultureInfo.GetCultureInfo("en-us"));
_importWizardViewModel = await InitializeViewModel <ImportWizardViewModel>();
_dbmlCompare = new DbmlCompare();
_eventDispatcher.GetEvent <SqlLinqConfigurationUpdatedEvents>().Subscribe(e =>
{
GetDbTitle();
});
}
/// <summary>
/// Return selected items
/// </summary>
/// <returns>Empty list if no item is selected</returns>
public AsyncObservableCollection <FileItem> GetSelectedFiles()
{
lock (_locker)
{
AsyncObservableCollection <FileItem> list = new AsyncObservableCollection <FileItem>();
foreach (FileItem fileItem in Files)
{
if (fileItem.IsChecked && fileItem.Visible)
{
list.Add(fileItem);
}
}
return(list);
}
}
public MailListWindow(EventBus eventBus, AsyncObservableCollection <EmailGroupModel> emailGroupList, ApplicationSettingsModel appSettings)
{
_eventBus = eventBus;
_emailGroupListModel = emailGroupList;
_appSettings = appSettings;
var screen = Screen.FromHandle(new WindowInteropHelper(this).Handle).WorkingArea;
_defaultWindowRect = new Rect(screen.Width - DefaultWidth, 0, DefaultWidth, screen.Height);
InitializeComponent();
SetWindowRect();
Closing += OnClosing;
_emailGroupListModel.CollectionChanged += EmailGroupListModelOnCollectionChanged;
}
public List <RgbColor> GetUsedColors()
{
if (Entry == null)
{
Entry = AsyncObservableCollection <EmbEntry> .Create();
}
List <RgbColor> colors = new List <RgbColor>();
foreach (var entry in Entry)
{
colors.Add(entry.GetDdsColor());
}
return(colors);
}
public SettingsWnd()
{
InitializeComponent();
foreach (Key key in Enum.GetValues(typeof(Keys)))
{
cmb_keys.Items.Add(key);
}
RotateFlipTypesValues = new AsyncObservableCollection <RotateFlipType>(Enum.GetValues(typeof(RotateFlipType)).Cast <RotateFlipType>().Distinct());
ServiceProvider.Settings.ApplyTheme(this);
qrcode.Text = ServiceProvider.Settings.Webaddress;
foreach (IMainWindowPlugin mainWindowPlugin in ServiceProvider.PluginManager.MainWindowPlugins)
{
cmb_mainwindow.Items.Add(mainWindowPlugin.DisplayName);
}
}
public void Run(List <string> f)
{
IsBusy = true;
_shouldStop = false;
_pathtoalign = Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location), "Tools", "align_image_stack.exe");
_pathtoenfuse = Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location), "Tools", "enfuse.exe");
_files = ServiceProvider.Settings.DefaultSession.GetSelectedFiles();
if (_files.Count < 2)
{
OnProgressChange("You should select more that 2 files");
OnActionDone();
return;
}
if (!File.Exists(_pathtoalign))
{
OnProgressChange("File not found: align_image_stack.exe");
OnProgressChange("Hugin not installed or not configured !");
OnActionDone();
return;
}
if (!File.Exists(_pathtoenfuse))
{
OnProgressChange("File not found: enfuse.exe");
OnProgressChange("Hugin not installed or not configured !");
OnActionDone();
return;
}
CopyFiles();
if (_shouldStop)
{
OnActionDone();
return;
}
AlignImages();
if (_shouldStop)
{
OnActionDone();
return;
}
Enfuse();
if (_shouldStop)
{
OnActionDone();
return;
}
OnProgressChange("Opeation done");
OnActionDone();
}
public CameraDeviceManager(string datafolder = null)
{
UseExperimentalDrivers = true;
LoadWiaDevices = true;
StartInNewThread = false;
DetectWebcams = true;
CustomDeviceClass = new Dictionary <string, Type>();
SelectedCameraDevice = new NotConnectedCameraDevice();
ConnectedDevices = new AsyncObservableCollection <ICameraDevice>();
_deviceEnumerator = new DeviceDescriptorEnumerator();
LiveViewImage = new ConcurrentDictionary <ICameraDevice, byte[]>();
LastCapturedImage = new ConcurrentDictionary <ICameraDevice, string>();
WifiDeviceProviders = new List <IWifiDeviceProvider>();
// prevent program crash in something wrong with wia
try
{
WiaDeviceManager = new DeviceManager();
WiaDeviceManager.RegisterEvent(Conts.wiaEventDeviceConnected, "*");
WiaDeviceManager.RegisterEvent(Conts.wiaEventDeviceDisconnected, "*");
WiaDeviceManager.OnEvent += DeviceManager_OnEvent;
Log.Error("Wia initialized");
}
catch (Exception exception)
{
Log.Error("Error initialize WIA", exception);
}
if (datafolder != null && Directory.Exists(datafolder))
{
try
{
var files = Directory.GetFiles(datafolder, "*.xml");
foreach (var file in files)
{
var device = DeviceDescription.Load(file);
if (device != null)
{
_deviceDescriptions.Add(device);
}
}
}
catch (Exception)
{
Log.Error("Error loading custom data");
}
}
}
public static AsyncObservableCollection <DataStoreItemViewModel> CreateCollection()
{
AsyncObservableCollection <DataStoreItemViewModel> res = new AsyncObservableCollection <DataStoreItemViewModel>();
res = (AsyncObservableCollection <DataStoreItemViewModel>)Dispatcher.Invoke(new Func <AsyncObservableCollection <DataStoreItemViewModel> >(() =>
{
AsyncObservableCollection <DataStoreItemViewModel> result;
logger.Trace("Invoke...");
result = new AsyncObservableCollection <DataStoreItemViewModel>();
logger.Trace("Created Collection - type = " + result.GetType());
logger.Trace("Invoke...End");
return(result);
}));
return(res);
}
public List <RgbColor> GetUsedColors()
{
List <RgbColor> colors = new List <RgbColor>();
if (Animations == null)
{
Animations = AsyncObservableCollection <EMA_Animation> .Create();
}
foreach (var anim in Animations)
{
colors.AddRange(anim.GetUsedColors());
}
return(colors);
}
public MainViewModel()
{
_Manager = Manager.Instance;
// 从配置文件导入参数表
//Global.LoadFactory(_Manager.Type);
//Global.ParameterChanged += OnParameterChanged;
//Global.Deserialize(TYPE_COFFEE.T_7319);
_Parameters = Global.ListItemParameter;
_CalibrationParameters = Global.ListItemParameterCalibration;
//Global.Serialize(TYPE_COFFEE.T_7319);
//for (int i = 0; i < Global.ListItemParameter.Count; i++)
//{
// _Parameters.Add(new Parameter()
// {
// Name = Global.ListItemName[i],
// FactoryMin = Global.ListItemParameter[i].StdMin.ToString(),
// FactoryMax = Global.ListItemParameter[i].StdMax.ToString()
// });
//}
//Global.Serialize(_Manager.Type);
//Global.Deserialize(_Manager.Type);
//for (int i = 0; i < Global.ListItemParameter.Count; i++)
//{
// _Parameters[i].UserMin = Global.ListItemParameter[i].StdMin.ToString();
// _Parameters[i].UserMax = Global.ListItemParameter[i].StdMax.ToString();
//}
_Products = new AsyncObservableCollection <ViewProduct>();
_Records = new AsyncObservableCollection <Record>();
_Type = _Manager.Type;
_QueryCommand = new RelayCommand(() => { _Manager.QueryDatabase(Time, Type, Item); });
_InitCommand = new RelayCommand(_Manager.Init);
_LoadFileParametersCommand = new RelayCommand(() => { Global.Deserialize(_Manager.Type); });
_SaveFileParametersCommand = new RelayCommand(() => { Global.Serialize(_Manager.Type); });
_CloseMainWindowCommand = new RelayCommand(() => { _Manager.Close(); });
_Manager.UpdateMainViewProducts += OnUpdateMainViewProducts;
_Manager.UpdateMainViewRecords += OnUpdateMainViewRecords;
_Manager.UpdateViewCalibrationResults += new Action <List <string> >(OnUpdateViewCalibrationResults);
_Items = new ObservableCollection <Item>();
for (int i = 0; i < Global.ListItemNameCalibration.Count; i++)
{
_Items.Add(new Item {
Name = Global.ListItemNameCalibration[i], Min = Global.ListItemParameterCalibration[i].UserMin.ToString(), Max = Global.ListItemParameterCalibration[i].UserMax.ToString()
});
}
_Manager.UpdateMainViewStatus += (s) => { Status = s; };
}
public Parameter GetParameter(string parameterName)
{
if (Parameters == null)
{
Parameters = AsyncObservableCollection <Parameter> .Create();
}
foreach (var parameter in Parameters)
{
if (parameter.Str_00 == parameterName)
{
return(parameter);
}
}
return(null);
}
public Material Clone()
{
Material newMaterial = new Material();
newMaterial.Str_00 = Str_00;
newMaterial.Str_32 = Str_32;
newMaterial.LocalCopy = true;
newMaterial.I_66 = I_66;
newMaterial.Parameters = AsyncObservableCollection <Parameter> .Create();
foreach (var param in Parameters)
{
newMaterial.Parameters.Add(param.Clone());
}
return(newMaterial);
}
public ClientsTableViewModel(IBankEntitiesContext bankEntities, IDialogService dialogService)
{
_bankEntities = bankEntities;
_dialogService = dialogService;
DeleteClientCommand = new DelegateCommand <ClientViewModel>(async vm => await DeleteSelectedClientAsync(vm));
AddClientCommand = new DelegateCommand(ShowAddClientDialog);
ClientViewModels = new AsyncObservableCollection <ClientViewModel>();
NavigatingFromCommand = new DelegateCommand <NavigatingCancelEventArgs>(NavigatingFrom);
NavigatedFromCommand = new DelegateCommand(NavigatedFrom);
NavigatedToCommand = new DelegateCommand(NavigatedTo);
FragmentNavigationCommand = new DelegateCommand(FragmentNavigation);
LoadedCommand = new DelegateCommand(async() => await LoadDataAsync());
IsVisibleChangedCommand = new DelegateCommand(VisibilityChanged);
}
private async void UpdateNews()
{
SpinnerVisible = true;
var result = await _webClient.GetAsync($@"{ApiAddress}/news/");
if (!result.IsSuccessStatusCode)
{
SpinnerVisible = false;
return;
}
var responseContent = await result.Content.ReadAsStringAsync();
NewsList = new AsyncObservableCollection <MagitekNews>(JsonConvert.DeserializeObject <List <MagitekNews> >(responseContent).OrderByDescending(r => r.Id));
SpinnerVisible = false;
}
public VisualSFMViewModel()
{
Output = new AsyncObservableCollection <string>();
InitCommands();
//CreateTempDir(true);
//MakeVisualSFMLaunchCommand();
ServiceProvider.FileTransfered += ServiceProvider_FileTransfered;
ServiceProvider.WindowsManager.Event += WindowsManager_Event;
LoadVisualSFMData();
ReloadCommand = new RelayCommand(LoadVisualSFMData);
GenerateCommand = new RelayCommand(Generate);
StopCommand = new RelayCommand(Stop);
SelectAllCommand = new CameraControl.Core.Classes.RelayCommand <object>(delegate { ServiceProvider.Settings.DefaultSession.SelectAll(); });
SelectNoneCommand = new CameraControl.Core.Classes.RelayCommand <object>(delegate { ServiceProvider.Settings.DefaultSession.SelectNone(); });
SelectInverCommand = new CameraControl.Core.Classes.RelayCommand <object>(delegate { ServiceProvider.Settings.DefaultSession.SelectInver(); });
SetProjetFolderCommand = new RelayCommand(SetProjetFolder);
}
public BAC.BAC_File ConvertToXv2(int skillID)
{
List <BAC.BAC_Entry> xv2BacEntries = new List <BAC.BAC_Entry>();
for (int i = 0; i < BacEntries.Count; i++)
{
xv2BacEntries.Add(BacEntries[i].ConvertToXv2(skillID));
}
return(new BAC.BAC_File()
{
I_20 = I_20,
I_80 = I_80,
F_32 = F_32,
BacEntries = AsyncObservableCollection <BAC.BAC_Entry> .Create(xv2BacEntries)
});
}
public void TestCreateExplorerItems()
{
//arrange
var explorerItem = new Mock <IExplorerItem>();
explorerItem.SetupGet(it => it.DisplayName).Returns("someDisplayName");
explorerItem.SetupGet(it => it.ResourceId).Returns(Guid.NewGuid());
explorerItem.SetupGet(it => it.ResourceType).Returns("Folder");
explorerItem.SetupGet(it => it.IsFolder).Returns(true);
explorerItem.SetupGet(it => it.ResourcePath).Returns("someDisplayName");
var childExplorerItem = new Mock <IExplorerItem>();
childExplorerItem.SetupGet(it => it.DisplayName).Returns("someDisplayName");
childExplorerItem.SetupGet(it => it.ResourceId).Returns(Guid.NewGuid());
childExplorerItem.SetupGet(it => it.ResourceType).Returns("Folder");
childExplorerItem.SetupGet(it => it.IsFolder).Returns(true);
childExplorerItem.SetupGet(it => it.ResourcePath).Returns("someDisplayName");
var parentMock = new Mock <IExplorerTreeItem>();
var collectionParent = new AsyncObservableCollection <IExplorerItemViewModel>();
parentMock.SetupGet(it => it.Children).Returns(collectionParent);
var collectionItem = new AsyncObservableCollection <IExplorerItem>()
{
childExplorerItem.Object
};
explorerItem.SetupGet(it => it.Children).Returns(collectionItem);
var serverMock = new Mock <IServer>();
var permissions = new List <IWindowsGroupPermission>();
serverMock.SetupGet(it => it.Permissions).Returns(permissions);
var items = new List <IExplorerItem>()
{
explorerItem.Object
};
_target.SelectAction = (a) => { };
//act
_target.CreateExplorerItemsSync(items, serverMock.Object, parentMock.Object, true, true);
//assert
Assert.IsFalse(_target.Children.Any());
parentMock.VerifySet(it => it.Children = It.IsAny <ObservableCollection <IExplorerItemViewModel> >());
// Assert.IsTrue(collection.Any());
}
public EMA_Command GetCommand(string parameter, string component)
{
if (Commands == null)
{
Commands = AsyncObservableCollection <EMA_Command> .Create();
}
foreach (var command in Commands)
{
if (command.Parameter.ToLower() == parameter.ToLower() && command.Component.ToLower() == component.ToLower())
{
return(command);
}
}
return(null);
}
public DiaryViewModel() : base()
{
logger.Trace("DiaryViewmodel()...");
_selectedDate = DateTime.Now.Date;
_diaries = new AsyncObservableCollection <Diary>();
var rooms = DesktopApplication.Librarian.GetItems(typeof(Room), new List <RetrievalCriteria>());
foreach (IDataStoreItem i in rooms)
{
if ((i as Room).CameraRoom)
{
Diary d = new Diary(this, (i as Room));
Diaries.Add(d);
}
}
logger.Trace(Diaries.Count + " Diaries created ");
}
public SettingsWnd()
{
AvailableKeys = new AsyncObservableCollection <string>();
InitializeComponent();
foreach (string key in Enum.GetNames(typeof(Key)))
{
AvailableKeys.Add(key);
}
RotateFlipTypesValues =
new AsyncObservableCollection <RotateFlipType>(
Enum.GetValues(typeof(RotateFlipType)).Cast <RotateFlipType>().Distinct());
foreach (IMainWindowPlugin mainWindowPlugin in ServiceProvider.PluginManager.MainWindowPlugins)
{
cmb_mainwindow.Items.Add(mainWindowPlugin.DisplayName);
}
DataContext = ServiceProvider.Settings;
}
private AsyncObservableCollection <Type0_Keyframe> ParseKeyframes(int keyframeCount, int keyframeListOffset, int floatOffset)
{
AsyncObservableCollection <Type0_Keyframe> keyframes = AsyncObservableCollection <Type0_Keyframe> .Create();
for (int i = 0; i < keyframeCount; i++)
{
keyframes.Add(new Type0_Keyframe()
{
Index = BitConverter.ToUInt16(rawBytes, keyframeListOffset),
Float = BitConverter.ToSingle(rawBytes, floatOffset)
});
keyframeListOffset += 2;
floatOffset += 4;
}
return(keyframes);
}
public XmlDataManager()
{
PropertyMapping = new AsyncObservableCollection <string>
{
PM_MODE,
PM_ISO,
PM_Shutter_Speed,
PM_Aperture,
PM_WhiteBalance,
PM_ExposureComp,
PM_Compression,
PM_MeteringMode,
PM_FocusMode,
PM_BATERY,
PM_Advanced
};
}
public MainWindowViewModel()
{
EditCommand = new RelayCommand(Edit);
ServiceProvider.Instance.DeviceManager.CameraConnected += DeviceManager_CameraConnected;
ServiceProvider.Instance.DeviceManager.CameraDisconnected += DeviceManager_CameraDisconnected;
ServiceProvider.Instance.DeviceManager.ConnectToCamera();
WorkFlows = new AsyncObservableCollection <WorkFlow>();
WorkFlows.Add(new WorkFlow()
{
Name = "Workflow 1", Description = "agsgsdg ggsgsfdg sgsdgdsfg sggsfgsd sgsdgsg "
});
WorkFlows.Add(new WorkFlow()
{
Name = "Workflow 2", Description = "agsgsdg ggsgsfdg sgsdgdsfg sggsfgsd sgsdgsg "
});
}
public static AsyncObservableCollection <T> SortEntries2 <T>(AsyncObservableCollection <T> entries) where T : ISortable, new()
{
//ObservableCollect doesn't have a Sort method, so we need to do our own (bad) one here.
if (entries != null)
{
var sortedEntries = SortEntries2(entries.ToList());
//To preserve the original ObservableCollection object, copy the sorted entries back into it rather than creating a new one:
for (int i = 0; i < entries.Count; i++)
{
entries[i] = sortedEntries[i];
}
}
return(entries);
}
