/// <summary>
/// コンストラクタ
/// </summary>
public ViewModel()
{
var options = _Model.GetCommandlineOptions();
InDirPath = new ReactiveProperty <string>(options.InputDirectory);
OutFilePath = new ReactiveProperty <string>(options.OutputFilePath);
Langages = new ReactiveCollection <LangComboboxItem>();
SelectedLangage = new ReactiveProperty <LangComboboxItem?>();
MaxSteps = new ReactiveProperty <int>(1);
CurrentStep = new ReactiveProperty <int>(0);
CanOperation = new ReactiveProperty <bool>(true);
// 操作可能かつ入力項目に不備がない場合に true にする
var canExport = new[] {
CanOperation,
InDirPath.Select(p => !string.IsNullOrEmpty(p)),
OutFilePath.Select(p => !string.IsNullOrEmpty(p)),
SelectedLangage.Select(l => l != null),
}.CombineLatestValuesAreAllTrue();
SelectInDirCommand = new ReactiveCommand(CanOperation).WithSubscribe(SelectInDir);
SelectOutPathCommand = new ReactiveCommand(CanOperation).WithSubscribe(SelectOutPath);
ExportCommand = new AsyncReactiveCommand(canExport, CanOperation).WithSubscribe(Export);
CloseCommand = new ReactiveCommand <Window>(CanOperation).WithSubscribe(Close);
// 入力元フォルダパスが変更された時、言語一覧を更新する
InDirPath.Subscribe(path =>
{
Langages.ClearOnScheduler();
Langages.AddRangeOnScheduler(_Model.GetLangages(path));
});
}
public static void AddRange <T>(this ReactiveCollection <T> source, IEnumerable <T> addList)
{
var aaa = Task.Run(() =>
{
source.AddRangeOnScheduler(addList);
});
aaa.Wait();
}
public void UpdateAppList()
{
apps.Clear();
apps.AddRangeOnScheduler(Process.GetProcesses()
.Where(n => !string.IsNullOrEmpty(n.MainWindowTitle))
.Where(n => !InValildApplicationMap.IsInVaild(n.MainWindowTitle))
.Where(n => n.MainWindowHandle != IntPtr.Zero)
.Where(n => n.MainModule.ModuleName != Process.GetCurrentProcess().MainModule.ModuleName)
.Select(n => new ApplicationInfo(n)));
}
public MainWindowViewModel()
{
// IFilteredReadOnlyObservableCollectionを使うためにTypeをReactivePropertySlimで包んでいる。
// 選んだ理由はINotifyPropertyChangedを実装しているからで、それ以上の意味はない。
var rc = new ReactiveCollection <ReactivePropertySlim <Type> >();
rc.AddRangeOnScheduler(XamlCreator.GetControlList().Select(x => new ReactivePropertySlim <Type>(x)));
bool FilterFunc(ReactivePropertySlim <Type> x)
{
return(string.IsNullOrWhiteSpace(this.SearchWord.Value) || x.Value.ToString().IndexOf(this.SearchWord.Value, StringComparison.OrdinalIgnoreCase) >= 0);
}
this.Controls = rc.ToFilteredReadOnlyObservableCollection(FilterFunc);
this.SearchWord.Subscribe(_ => {
this.Controls.Refresh(FilterFunc);
});
this.Xaml = this.SelectedControl.Select(x => XamlCreator.Create(x?.Value)).ToReadOnlyReactivePropertySlim();
}
public ServerStatusViewModel(IRegionManager regionManager, IServerState state) : base(regionManager)
{
var list = state.GetAllServerState();
Status = new ReactiveCollection <Server>();
Status.AddRange(list.ToList());
AllServerConnections = new ReactiveProperty <long>
{
Value = list.Sum(x => x.OnlineNums)
};
Observable.Interval(TimeSpan.FromSeconds(10))
.Subscribe(_ =>
{
var list = state.GetAllServerState();
Status.ClearOnScheduler();
Status.AddRangeOnScheduler(list.ToList());
AllServerConnections.Value = list.Sum(x => x.OnlineNums);
});
}
/// <summary>
/// コンストラクタ
/// </summary>
public DataExportViewModel(string inDirPath, string outFilePath)
{
InDirPath = new ReactiveProperty <string>(inDirPath,
mode: ReactivePropertyMode.RaiseLatestValueOnSubscribe);
_UnableToGetLanguages = new ReactivePropertySlim <bool>(false);
InDirPath.SetValidateNotifyError(
_ => _UnableToGetLanguages.Select(isError => isError ? "Error" : null));
_OutFilePath = outFilePath;
Languages = new ReactiveCollection <LangComboboxItem>();
SelectedLanguage = new ReactivePropertySlim <LangComboboxItem?>();
MaxSteps = new ReactivePropertySlim <int>(1);
CurrentStep = new ReactivePropertySlim <int>(0);
CanOperation = _BusyNotifier.Inverse().ToReadOnlyReactivePropertySlim();
// 操作可能かつ入力項目に不備がない場合に true にする
var canExport = new[] {
CanOperation,
InDirPath.Select(p => !string.IsNullOrEmpty(p)),
SelectedLanguage.Select(l => l != null),
}.CombineLatestValuesAreAllTrue();
SelectInDirCommand = new ReactiveCommand(CanOperation).WithSubscribe(SelectInDir);
ExportCommand = new AsyncReactiveCommand(canExport).WithSubscribe(Export);
ClosingCommand = new ReactiveCommand <CancelEventArgs>().WithSubscribe(Closing);
// 入力元フォルダパスに値が代入された時、言語一覧を更新する
InDirPath.ObserveOn(ThreadPoolScheduler.Instance).Subscribe(path =>
{
using var _ = _BusyNotifier.ProcessStart();
_UnableToGetLanguages.Value = false;
Languages.ClearOnScheduler();
var(success, languages) = _Model.GetLanguages(path);
_UnableToGetLanguages.Value = !success;
Languages.AddRangeOnScheduler(languages);
});
}
void ResetItems()
{
IEnumerable <IVideoContent> currentSource = _sourceItems;
if (PlayerSettings.IsShuffleEnable)
{
currentSource = currentSource.Shuffle(_shuffleRandom);
}
if (PlayerSettings.IsReverseModeEnable)
{
currentSource = currentSource.Reverse();
}
var items = currentSource.ToList();
_items.ClearOnScheduler();
_items.AddRangeOnScheduler(items);
CurrentIndex = items.Any() ? items.IndexOf(Current) : 0;
RaisePropertyChanged(nameof(CanGoBack));
RaisePropertyChanged(nameof(CanGoNext));
}
public User(string name, List <string> favorites)
{
Name = new ReactiveProperty <string>(name);
Favorites = new ReactiveCollection <string>();
Favorites.AddRangeOnScheduler(favorites);
}
public SearchSettingsFlyoutViewModel()
{
Model = new SearchSettingsFlyoutModel();
Tokens = Model.ToReactivePropertyAsSynchronized(x => x.Tokens);
IconSource = new ReactiveProperty <string>("http://localhost/");
StatusSearchWords = new ReactiveProperty <string>();
UserSearchWords = new ReactiveProperty <string>();
PivotSelectedIndex = new ReactiveProperty <int>(0);
PivotSelectedIndex.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(async x =>
{
if (x == 2)
{
await Model.UpdateSavedSearches();
await Model.UpdateTrends();
}
});
SavedSearchesScreenName = Model.ObserveProperty(x => x.SavedSearchesScreenName).ToReactiveProperty();
TrendPlace = Model.ObserveProperty(x => x.TrendsPlace).ToReactiveProperty();
AdvancedSearchOpen = new ReactiveProperty <bool>();
AdvancedSearchContentOpen = new ReactiveProperty <bool>();
AdvancedSearchEngagementOpen = new ReactiveProperty <bool>();
AdvancedSearchContentRetweetsOption = new ReactiveProperty <int>(0);
AdvancedSearchContentShowingOption = new ReactiveProperty <int>(0);
AdvancedSearchContentWrittenInOption = new ReactiveProperty <int>(0);
AdvancedSearchEngagementFavoritesCount = new ReactiveProperty <int>(0);
AdvancedSearchEngagementRetweetsCount = new ReactiveProperty <int>(0);
UpdatingStatusSearch = Model.ObserveProperty(x => x.UpdatingStatusSearch).ToReactiveProperty();
UpdatingUserSearch = Model.ObserveProperty(x => x.UpdatingUserSearch).ToReactiveProperty();
StatusSuggestion = new ReactiveCollection <string>();
UserSuggestion = new ReactiveCollection <string>();
ClearCommand = new ReactiveCommand();
ClearCommand.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(x =>
{
if (AdvancedSearchOpen.Value)
{
AdvancedSearchContentOpen.Value = false;
AdvancedSearchEngagementOpen.Value = false;
AdvancedSearchOpen.Value = false;
}
StatusSearchWords.Value = "";
UserSearchWords.Value = "";
PivotSelectedIndex.Value = 0;
Model.Statuses.Clear();
Model.Users.Clear();
});
UpdateStatusSearchCommand = new ReactiveCommand();
UpdateStatusSearchCommand.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(async x =>
{
var e = x as AutoSuggestBoxQuerySubmittedEventArgs;
if (!string.IsNullOrWhiteSpace(e?.QueryText))
{
StatusSearchWords.Value = e.QueryText;
}
if (string.IsNullOrWhiteSpace(StatusSearchWords.Value))
{
Model.Statuses.Clear();
Model.StatusSearchWords = "";
return;
}
var searchWords = StatusSearchWords.Value;
switch (AdvancedSearchContentShowingOption.Value)
{
case 1:
searchWords += " filter:images";
break;
case 2:
searchWords += " filter:videos";
break;
case 3:
searchWords += " filter:vine";
break;
case 4:
searchWords += " filter:media";
break;
case 5:
searchWords += " filter:links";
break;
}
switch (AdvancedSearchContentWrittenInOption.Value)
{
case 1:
searchWords += " lang:en";
break;
case 2:
searchWords += " lang:ja";
break;
}
switch (AdvancedSearchContentRetweetsOption.Value)
{
case 1:
searchWords += " exclude:retweets";
break;
}
if (AdvancedSearchEngagementRetweetsCount.Value != 0)
{
searchWords += " min_retweets:" + AdvancedSearchEngagementRetweetsCount.Value.ToString();
}
if (AdvancedSearchEngagementFavoritesCount.Value != 0)
{
searchWords += " min_faves:" + AdvancedSearchEngagementFavoritesCount.Value.ToString();
}
if (Model.StatusSearchWords == searchWords)
{
await Model.UpdateStatuses(clear: false);
}
else
{
Model.StatusSearchWords = searchWords;
await Model.UpdateStatuses();
}
});
UpdateUserSearchCommand = new ReactiveCommand();
UpdateUserSearchCommand.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(async x =>
{
var e = x as AutoSuggestBoxQuerySubmittedEventArgs;
if (!string.IsNullOrWhiteSpace(e?.QueryText))
{
UserSearchWords.Value = e.QueryText;
}
if (string.IsNullOrWhiteSpace(UserSearchWords.Value))
{
Model.Users.Clear();
Model.UserSearchWords = "";
return;
}
Model.UserSearchWords = UserSearchWords.Value;
await Model.UpdateUsers();
});
TextChangedStatusSearchCommand = new ReactiveCommand();
TextChangedStatusSearchCommand.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(y =>
{
var e = y as AutoSuggestBoxTextChangedEventArgs;
if (e == null || string.IsNullOrWhiteSpace(StatusSearchWords.Value))
{
StatusSuggestion.ClearOnScheduler();
return;
}
IEnumerable <string> suggestHashtags;
lock (Connecter.Instance.TweetCollecter[Tokens.Value.UserId].EntitiesObjectsLock)
{
suggestHashtags = Connecter.Instance.TweetCollecter[Tokens.Value.UserId]
.HashTagObjects.Where(x => x.StartsWith(StatusSearchWords.Value.TrimStart('#')))
.OrderBy(x => x).Select(x => "#" + x);
}
if (suggestHashtags.Any())
{
StatusSuggestion.ClearOnScheduler();
StatusSuggestion.AddRangeOnScheduler(suggestHashtags);
}
else
{
StatusSuggestion.ClearOnScheduler();
}
});
TextChangedUserSearchCommand = new ReactiveCommand();
TextChangedUserSearchCommand.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(y =>
{
var e = y as AutoSuggestBoxTextChangedEventArgs;
if (e == null || string.IsNullOrWhiteSpace(UserSearchWords.Value) &&
UserSearchWords.Value.Length <= 1)
{
UserSuggestion.ClearOnScheduler();
return;
}
IEnumerable <string> suggestUsers;
lock (Connecter.Instance.TweetCollecter[Tokens.Value.UserId].EntitiesObjectsLock)
{
suggestUsers = Connecter.Instance.TweetCollecter[Tokens.Value.UserId]
.ScreenNameObjects.Where(x => x.StartsWith(UserSearchWords.Value.TrimStart('@')))
.OrderBy(x => x);
}
if (suggestUsers.Any())
{
UserSuggestion.ClearOnScheduler();
UserSuggestion.AddRangeOnScheduler(suggestUsers);
}
else
{
UserSuggestion.ClearOnScheduler();
}
});
SaveSearchCommand = new ReactiveCommand();
SaveSearchCommand.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(async x =>
{
if (string.IsNullOrWhiteSpace(Model.StatusSearchWords))
{
return;
}
await Model.CreateSavedSearches(Model.StatusSearchWords);
});
DeleteHistoryCommand = new ReactiveCommand();
DeleteHistoryCommand.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(x =>
{
var manager = new SearchSuggestionManager();
manager.ClearHistory();
});
StatusesIncrementalLoadCommand = new ReactiveCommand();
StatusesIncrementalLoadCommand.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(async x =>
{
if (Model.Statuses.Count <= 0)
{
return;
}
var id = Model.Statuses.Last().Id;
var status = Model.Statuses.Last();
if (status.HasRetweetInformation)
{
id = status.RetweetInformation.Id;
}
await Model.UpdateStatuses(id);
});
UsersIncrementalLoadCommand = new ReactiveCommand();
UsersIncrementalLoadCommand.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(async x => { await Model.UpdateUsers(true); });
SavedSearchesSelectCommand = new ReactiveCommand();
SavedSearchesSelectCommand.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(x =>
{
var e = x as ItemClickEventArgs;
if (e == null)
{
return;
}
var searchQuery = e.ClickedItem as SearchQueryViewModel;
StatusSearchWords.Value = searchQuery.Model.Name;
UpdateStatusSearchCommand.Execute();
PivotSelectedIndex.Value = 0;
});
TrendsSelectCommand = new ReactiveCommand();
TrendsSelectCommand.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(x =>
{
var e = x as ItemClickEventArgs;
if (e == null)
{
return;
}
var trend = e.ClickedItem as TrendViewModel;
StatusSearchWords.Value = trend.Model.Name;
UpdateStatusSearchCommand.Execute();
PivotSelectedIndex.Value = 0;
});
Notice.Instance.SearchSettingsFlyoutDeleteSearchQueryCommand.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(async x =>
{
var searchQuery = x as SearchQueryViewModel;
if (searchQuery == null || searchQuery.Model.Id == 0)
{
return;
}
await Model.DestroySavedSearches(searchQuery.Model.Id);
});
AdvancedSearchCommand = new ReactiveCommand();
AdvancedSearchCommand.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(_ =>
{
if (AdvancedSearchOpen.Value)
{
AdvancedSearchContentOpen.Value = false;
AdvancedSearchEngagementOpen.Value = false;
}
AdvancedSearchOpen.Value = !AdvancedSearchOpen.Value;
});
AdvancedSearchContentCommand = new ReactiveCommand();
AdvancedSearchContentCommand.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(_ => AdvancedSearchContentOpen.Value = !AdvancedSearchContentOpen.Value);
AdvancedSearchEngagementCommand = new ReactiveCommand();
AdvancedSearchEngagementCommand.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(_ => AdvancedSearchEngagementOpen.Value = !AdvancedSearchEngagementOpen.Value);
AddColumnCommand = new ReactiveCommand();
AddColumnCommand.SubscribeOn(ThreadPoolScheduler.Default)
.Subscribe(x =>
{
if (string.IsNullOrWhiteSpace(Model.StatusSearchWords))
{
return;
}
var columnSetting = new ColumnSetting
{
Action = SettingSupport.ColumnTypeEnum.Search,
AutoRefresh = false,
AutoRefreshTimerInterval = 180.0,
Filter = "()",
Name = "Search : " + Model.StatusSearchWords,
Parameter = Model.StatusSearchWords,
Streaming = false,
Index = -1,
DisableStartupRefresh = false,
FetchingNumberOfTweet = 40
};
Notice.Instance.AddColumnCommand.Execute(columnSetting);
});
Statuses = Model.Statuses.ToReadOnlyReactiveCollection(x => new StatusViewModel(x, Tokens.Value.UserId));
Users = Model.Users.ToReadOnlyReactiveCollection(x => new UserViewModel(x));
Trends = Model.Trends.ToReadOnlyReactiveCollection(x => new TrendViewModel(x));
SavedSearches = Model.SavedSearches.ToReadOnlyReactiveCollection(x => new SearchQueryViewModel(x));
Notice = Notice.Instance;
}