private void ResetAlignment()
{
_words.Clear();
ColumnCount = 0;
SelectedColumn = 0;
SelectedWord = null;
}
private void WordsChanged(object sender, NotifyCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
AddWords(e.NewItems.Cast <WordViewModel>());
break;
case NotifyCollectionChangedAction.Remove:
RemoveWords(e.OldItems.Cast <WordViewModel>());
break;
case NotifyCollectionChangedAction.Replace:
RemoveWords(e.OldItems.Cast <WordViewModel>());
AddWords(e.NewItems.Cast <WordViewModel>());
break;
case NotifyCollectionChangedAction.Reset:
_selectedWords.Clear();
using (_selectedSegmentWords.BulkUpdate())
{
_selectedSegmentWords.Clear();
AddWords(_words);
}
break;
}
ResetSearch();
UpdateWordCounts();
}
private void ResetAlignment()
{
if (IsEmpty)
{
return;
}
_words.Clear();
ColumnCount = 0;
IsEmpty = true;
}
public void TestClear()
{
for (int i = 0; i < 5; i++)
{
bindableStringList.Add("testA");
}
bindableStringList.Clear();
Assert.IsEmpty(bindableStringList);
}
public void UpdateTargetScreen(Drawable targetScreen)
{
this.targetScreen = targetScreen;
SelectedComponents.Clear();
Scheduler.AddOnce(loadBlueprintContainer);
void loadBlueprintContainer()
{
content.Children = new Drawable[]
{
new SkinBlueprintContainer(targetScreen),
};
}
}
/// <summary>
/// Remove all <see cref="ControlPointGroup"/>s and return to a pristine state.
/// </summary>
public virtual void Clear()
{
groups.Clear();
timingPoints.Clear();
difficultyPoints.Clear();
effectPoints.Clear();
}
public void Setup() => Schedule(() =>
{
Child = new Container
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Size = new Vector2(300, 500),
Child = playlistOverlay = new PlaylistOverlay
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.X,
State = { Value = Visibility.Visible }
}
};
beatmapSets.Clear();
for (int i = 0; i < 100; i++)
{
beatmapSets.Add(new BeatmapSetInfo
{
Metadata = new BeatmapMetadata
{
// Create random metadata, then we can check if sorting works based on these
Artist = "Some Artist " + RNG.Next(0, 9),
Title = $"Some Song {i + 1}",
AuthorString = "Some Guy " + RNG.Next(0, 9),
},
DateAdded = DateTimeOffset.UtcNow,
});
}
playlistOverlay.BeatmapSets.BindTo(beatmapSets);
});
private void load()
{
IsConnected.BindValueChanged(connected => Schedule(() =>
{
if (connected.NewValue)
{
// get all the users that were previously being watched
int[] users = watchingUsers.ToArray();
watchingUsers.Clear();
// resubscribe to watched users.
foreach (int userId in users)
{
WatchUser(userId);
}
// re-send state in case it wasn't received
if (IsPlaying)
{
BeginPlayingInternal(currentState);
}
}
else
{
playingUsers.Clear();
playingUserStates.Clear();
}
}), true);
}
public void Reload()
{
ClearInternal();
components.Clear();
ComponentsLoaded = false;
content = CurrentSkin.GetDrawableComponent(new SkinnableTargetComponent(Target)) as SkinnableTargetComponentsContainer;
cancellationSource?.Cancel();
cancellationSource = null;
if (content != null)
{
LoadComponentAsync(content, wrapper =>
{
AddInternal(wrapper);
components.AddRange(wrapper.Children.OfType <ISkinnableDrawable>());
ComponentsLoaded = true;
}, (cancellationSource = new CancellationTokenSource()).Token);
}
else
{
ComponentsLoaded = true;
}
}
public void DeleteAll()
{
Collections.Clear();
PostNotification?.Invoke(new ProgressCompletionNotification {
Text = "Deleted all collections!"
});
}
public void ClearRooms()
{
Debug.Assert(ThreadSafety.IsUpdateThread);
rooms.Clear();
notifyRoomsUpdated();
}
private void placeComponent(Type type)
{
var targetContainer = getTarget(SkinnableTarget.MainHUDComponents);
if (targetContainer == null)
{
return;
}
if (!(Activator.CreateInstance(type) is ISkinnableDrawable component))
{
throw new InvalidOperationException($"Attempted to instantiate a component for placement which was not an {typeof(ISkinnableDrawable)}.");
}
var drawableComponent = (Drawable)component;
// give newly added components a sane starting location.
drawableComponent.Origin = Anchor.TopCentre;
drawableComponent.Anchor = Anchor.TopCentre;
drawableComponent.Y = targetContainer.DrawSize.Y / 2;
targetContainer.Add(component);
SelectedComponents.Clear();
SelectedComponents.Add(component);
}
protected override void Update()
{
base.Update();
ControlPointVisualiser[] ordered = controlPointContainer.OrderBy(p => p.PointPosition.Value.X).ToArray();
for (int i = 0; i < ordered.Length; i++)
{
ordered[i].Last = i > 0 ? ordered[i - 1] : null;
ordered[i].Next = i < ordered.Length - 1 ? ordered[i + 1] : null;
}
var vectorPath = new List <Vector2> {
new Vector2(0, DrawHeight)
};
vectorPath.AddRange(ordered.Select(p => p.PointPosition.Value));
vectorPath.Add(new Vector2(DrawWidth, 0));
var bezierPath = PathApproximator.ApproximateBezier(vectorPath.ToArray());
path.Vertices = bezierPath;
path.Position = -path.PositionInBoundingBox(Vector2.Zero);
easingVertices.Clear();
easingVertices.AddRange(bezierPath.Select(p => Vector2.Divide(p, DrawSize)).Select(p => new Vector2(p.X, 1 - p.Y)));
}
private void load()
{
IsConnected.BindValueChanged(connected => Schedule(() =>
{
if (connected.NewValue)
{
// get all the users that were previously being watched
int[] users = watchedUsers.ToArray();
watchedUsers.Clear();
// resubscribe to watched users.
foreach (int userId in users)
{
WatchUser(userId);
}
// re-send state in case it wasn't received
if (IsPlaying)
{
// TODO: this is likely sent out of order after a reconnect scenario. needs further consideration.
BeginPlayingInternal(currentState);
}
}
else
{
playingUsers.Clear();
watchedUserStates.Clear();
}
}), true);
}
public Task LeaveRoom()
{
// The join may have not completed yet, so certain tasks that either update the room or reference the room should be cancelled.
// This includes the setting of Room itself along with the initial update of the room settings on join.
joinCancellationSource?.Cancel();
// Leaving rooms is expected to occur instantaneously whilst the operation is finalised in the background.
// However a few members need to be reset immediately to prevent other components from entering invalid states whilst the operation hasn't yet completed.
// For example, if a room was left and the user immediately pressed the "create room" button, then the user could be taken into the lobby if the value of Room is not reset in time.
var scheduledReset = scheduleAsync(() =>
{
APIRoom = null;
Room = null;
CurrentMatchPlayingItem.Value = null;
PlayingUserIds.Clear();
RoomUpdated?.Invoke();
});
return(joinOrLeaveTaskChain.Add(async() =>
{
await scheduledReset.ConfigureAwait(false);
await LeaveRoomInternal().ConfigureAwait(false);
}));
}
public void Setup() => Schedule(() =>
{
Child = new Container
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Size = new Vector2(300, 500),
Child = playlistOverlay = new PlaylistOverlay
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.X,
State = { Value = Visibility.Visible }
}
};
beatmapSets.Clear();
for (int i = 0; i < 100; i++)
{
beatmapSets.Add(TestResources.CreateTestBeatmapSetInfo().ToLiveUnmanaged());
}
first = beatmapSets.First();
playlistOverlay.BeatmapSets.BindTo(beatmapSets);
});
/// <summary>
/// Remove all <see cref="ControlPointGroup"/>s and return to a pristine state.
/// </summary>
public void Clear()
{
groups.Clear();
timingPoints.Clear();
difficultyPoints.Clear();
samplePoints.Clear();
effectPoints.Clear();
}
public virtual void SetUpSteps()
{
AddStep("reset counts", () =>
{
spectatorClient.Invocations.Clear();
lastHeaders.Clear();
});
AddStep("set local user", () => ((DummyAPIAccess)API).LocalUser.Value = new APIUser
{
Id = 1,
});
AddStep("populate users", () =>
{
MultiplayerUsers.Clear();
for (int i = 0; i < TOTAL_USERS; i++)
{
var user = CreateUser(i);
MultiplayerUsers.Add(user);
watchedUserStates[i] = new SpectatorState
{
BeatmapID = 0,
RulesetID = 0,
Mods = user.Mods,
MaximumScoringValues = new ScoringValues
{
BaseScore = 10000,
MaxCombo = 1000,
CountBasicHitObjects = 1000
}
};
}
});
AddStep("create leaderboard", () =>
{
Leaderboard?.Expire();
Beatmap.Value = CreateWorkingBeatmap(Ruleset.Value);
LoadComponentAsync(Leaderboard = CreateLeaderboard(), Add);
});
AddUntilStep("wait for load", () => Leaderboard.IsLoaded);
AddStep("check watch requests were sent", () =>
{
foreach (var user in MultiplayerUsers)
{
spectatorClient.Verify(s => s.WatchUser(user.UserID), Times.Once);
}
});
}
public void Basic()
{
var i = items_to_add;
AddStep("click dropdown1", () => toggleDropdownViaClick(styledDropdown));
AddAssert("dropdown is open", () => styledDropdown.Menu.State == MenuState.Open);
AddRepeatStep("add item", () => styledDropdown.AddDropdownItem("test " + i++), items_to_add);
AddAssert("item count is correct", () => styledDropdown.Items.Count() == items_to_add * 2);
AddStep($"Set dropdown1 height to {explicit_height}", () =>
{
calculatedHeight = styledDropdown.Menu.Height;
styledDropdown.Menu.MaxHeight = explicit_height;
});
AddAssert($"dropdown1 height is {explicit_height}", () => styledDropdown.Menu.Height == explicit_height);
AddStep($"Set dropdown1 height to {float.PositiveInfinity}", () => styledDropdown.Menu.MaxHeight = float.PositiveInfinity);
AddAssert("dropdown1 height is calculated automatically", () => styledDropdown.Menu.Height == calculatedHeight);
AddStep("click item 13", () => styledDropdown.SelectItem(styledDropdown.Menu.Items[13]));
AddAssert("dropdown1 is closed", () => styledDropdown.Menu.State == MenuState.Closed);
AddAssert("item 13 is selected", () => styledDropdown.Current.Value == styledDropdown.Items.ElementAt(13));
AddStep("select item 15", () => styledDropdown.Current.Value = styledDropdown.Items.ElementAt(15));
AddAssert("item 15 is selected", () => styledDropdown.Current.Value == styledDropdown.Items.ElementAt(15));
AddStep("click dropdown1", () => toggleDropdownViaClick(styledDropdown));
AddAssert("dropdown1 is open", () => styledDropdown.Menu.State == MenuState.Open);
AddStep("click dropdown2", () => toggleDropdownViaClick(styledDropdownMenu2));
AddAssert("dropdown1 is closed", () => styledDropdown.Menu.State == MenuState.Closed);
AddAssert("dropdown2 is open", () => styledDropdownMenu2.Menu.State == MenuState.Open);
AddStep("select 'invalid'", () => styledDropdown.Current.Value = "invalid");
AddAssert("'invalid' is selected", () => styledDropdown.Current.Value == "invalid");
AddAssert("label shows 'invalid'", () => styledDropdown.Header.Label == "invalid");
AddStep("select item 2", () => styledDropdown.Current.Value = styledDropdown.Items.ElementAt(2));
AddAssert("item 2 is selected", () => styledDropdown.Current.Value == styledDropdown.Items.ElementAt(2));
AddStep("clear bindable list", () => bindableList.Clear());
AddStep("click dropdown3", () => toggleDropdownViaClick(bindableDropdown));
AddAssert("no elements in bindable dropdown", () => !bindableDropdown.Items.Any());
AddStep("add items to bindable", () => bindableList.AddRange(new[] { "one", "two", "three" }));
AddAssert("three items in dropdown", () => bindableDropdown.Items.Count() == 3);
AddStep("select three", () => bindableDropdown.Current.Value = "three");
AddStep("remove first item from bindable", () => bindableList.RemoveAt(0));
AddAssert("two items in dropdown", () => bindableDropdown.Items.Count() == 2);
AddAssert("current value still three", () => bindableDropdown.Current.Value == "three");
AddStep("remove three", () => bindableList.Remove("three"));
AddAssert("current value should be two", () => bindableDropdown.Current.Value == "two");
}
public void UpdateTargetScreen(Drawable targetScreen)
{
this.targetScreen = targetScreen;
SelectedComponents.Clear();
Scheduler.AddOnce(loadBlueprintContainer);
Scheduler.AddOnce(populateSettings);
void loadBlueprintContainer()
{
content.Child = new SkinBlueprintContainer(targetScreen);
componentsSidebar.Child = new SkinComponentToolbox(getFirstTarget() as CompositeDrawable)
{
RequestPlacement = placeComponent
};
}
}
private void load(IAPIProvider api)
{
connector = api.GetHubConnector(nameof(SpectatorStreamingClient), endpoint);
if (connector != null)
{
connector.ConfigureConnection = connection =>
{
// until strong typed client support is added, each method must be manually bound
// (see https://github.com/dotnet/aspnetcore/issues/15198)
connection.On <int, SpectatorState>(nameof(ISpectatorClient.UserBeganPlaying), ((ISpectatorClient)this).UserBeganPlaying);
connection.On <int, FrameDataBundle>(nameof(ISpectatorClient.UserSentFrames), ((ISpectatorClient)this).UserSentFrames);
connection.On <int, SpectatorState>(nameof(ISpectatorClient.UserFinishedPlaying), ((ISpectatorClient)this).UserFinishedPlaying);
};
isConnected.BindTo(connector.IsConnected);
isConnected.BindValueChanged(connected =>
{
if (connected.NewValue)
{
// get all the users that were previously being watched
int[] users;
lock (userLock)
{
users = watchingUsers.ToArray();
watchingUsers.Clear();
}
// resubscribe to watched users.
foreach (var userId in users)
{
WatchUser(userId);
}
// re-send state in case it wasn't received
if (isPlaying)
{
beginPlaying();
}
}
else
{
lock (userLock)
{
playingUsers.Clear();
playingUserStates.Clear();
}
}
}, true);
}
}
private void load(LyricEditorColourProvider colourProvider, ILyricEditorState state)
{
hoveredBackground.Colour = colourHover = colourProvider.Background1(LyricEditorMode.CreateTimeTag);
colourSelected = colourProvider.Colour3(LyricEditorMode.CreateTimeTag);
// update selected state by bindable.
selectedTimeTags = state.SelectedTimeTags.GetBoundCopy();
selectedTimeTags.BindCollectionChanged((a, b) =>
{
selected = selectedTimeTags.Contains(timeTag);
updateState();
});
Action = () =>
{
// navigate to current lyric.
switch (state.Mode)
{
case LyricEditorMode.CreateTimeTag:
state.BindableCaretPosition.Value = new TimeTagIndexCaretPosition(lyric, timeTag?.Index ?? new TextIndex());
break;
case LyricEditorMode.RecordTimeTag:
state.BindableCaretPosition.Value = new TimeTagCaretPosition(lyric, timeTag);
break;
case LyricEditorMode.AdjustTimeTag:
state.BindableCaretPosition.Value = new NavigateCaretPosition(lyric);
break;
default:
throw new IndexOutOfRangeException(nameof(state.Mode));
}
// set current time-tag as selected.
selectedTimeTags.Clear();
if (timeTag == null)
{
return;
}
// select time-tag is not null.
selectedTimeTags.Add(timeTag);
if (timeTag.Time == null)
{
return;
}
// seek to target time-tag time if time-tag has time.
clock.Seek(timeTag.Time.Value);
};
}
public void UpdateTargetScreen(Drawable targetScreen)
{
this.targetScreen = targetScreen;
SelectedComponents.Clear();
// Immediately clear the previous blueprint container to ensure it doesn't try to interact with the old target.
content?.Clear();
Scheduler.AddOnce(loadBlueprintContainer);
Scheduler.AddOnce(populateSettings);
void loadBlueprintContainer()
{
content.Child = new SkinBlueprintContainer(targetScreen);
componentsSidebar.Child = new SkinComponentToolbox(getFirstTarget() as CompositeDrawable)
{
RequestPlacement = placeComponent
};
}
}
private void Import()
{
IEnumerable <Tuple <string, string> > mappings;
if (_importService.ImportSegmentMappings(this, out mappings))
{
_mappings.Clear();
foreach (Tuple <string, string> mapping in mappings)
{
_mappings.Add(new SegmentMappingViewModel(_projectService.Project.Segmenter, mapping.Item1, mapping.Item2));
}
IsChanged = true;
}
}
/// <summary>
/// Reload all components in this container from the current skin.
/// </summary>
public void Reload()
{
ClearInternal();
components.Clear();
content = CurrentSkin.GetDrawableComponent(new SkinnableTargetComponent(Target)) as SkinnableTargetComponentsContainer;
if (content != null)
{
LoadComponentAsync(content, wrapper =>
{
AddInternal(wrapper);
components.AddRange(wrapper.Children.OfType <ISkinnableDrawable>());
});
}
}
private void onSelectedRoomChanged(ValueChangedEvent <Room> room)
{
if (room.OldValue != null)
{
playlist.UnbindFrom(room.OldValue.Playlist);
}
if (room.NewValue != null)
{
playlist.BindTo(room.NewValue.Playlist);
}
else
{
playlist.Clear();
}
}
private void generateControlPoints()
{
float midpoint = (startAngle + endAngle) / 2;
Vector2 polarToCartesian(float r, float theta) =>
new Vector2(
r * MathF.Cos(MathHelper.DegreesToRadians(theta)),
r * MathF.Sin(MathHelper.DegreesToRadians(theta)));
controlPoints.Clear();
controlPoints.AddRange(new[]
{
polarToCartesian(radius, startAngle),
polarToCartesian(radius, midpoint),
polarToCartesian(radius, endAngle)
});
}
public virtual void SetUpSteps()
{
AddStep("reset counts", () =>
{
spectatorClient.Invocations.Clear();
lastHeaders.Clear();
});
AddStep("set local user", () => ((DummyAPIAccess)API).LocalUser.Value = new APIUser
{
Id = 1,
});
AddStep("populate users", () =>
{
MultiplayerUsers.Clear();
for (int i = 0; i < total_users; i++)
{
MultiplayerUsers.Add(CreateUser(i));
}
});
AddStep("create leaderboard", () =>
{
Leaderboard?.Expire();
Beatmap.Value = CreateWorkingBeatmap(Ruleset.Value);
var playableBeatmap = Beatmap.Value.GetPlayableBeatmap(Ruleset.Value);
OsuScoreProcessor scoreProcessor = new OsuScoreProcessor();
scoreProcessor.ApplyBeatmap(playableBeatmap);
Child = scoreProcessor;
LoadComponentAsync(Leaderboard = CreateLeaderboard(scoreProcessor), Add);
});
AddUntilStep("wait for load", () => Leaderboard.IsLoaded);
AddStep("check watch requests were sent", () =>
{
foreach (var user in MultiplayerUsers)
{
spectatorClient.Verify(s => s.WatchUser(user.UserID), Times.Once);
}
});
}
public virtual Task LeaveRoom()
{
Scheduler.Add(() =>
{
if (Room == null)
{
return;
}
apiRoom = null;
Room = null;
CurrentMatchPlayingUserIds.Clear();
RoomUpdated?.Invoke();
}, false);
return(Task.CompletedTask);
}
private void load()
{
Dependencies.Cache(config = new OsuConfigManager(LocalStorage));
Dependencies.CacheAs(spectatorClient.Object);
Dependencies.CacheAs(multiplayerClient.Object);
// To emulate `MultiplayerClient.CurrentMatchPlayingUserIds` we need a bindable list of *only IDs*.
// This tracks the list of users 1:1.
MultiplayerUsers.BindCollectionChanged((c, e) =>
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
Debug.Assert(e.NewItems != null);
foreach (var user in e.NewItems.OfType <MultiplayerRoomUser>())
{
multiplayerUserIds.Add(user.UserID);
}
break;
case NotifyCollectionChangedAction.Remove:
Debug.Assert(e.OldItems != null);
foreach (var user in e.OldItems.OfType <MultiplayerRoomUser>())
{
multiplayerUserIds.Remove(user.UserID);
}
break;
case NotifyCollectionChangedAction.Reset:
multiplayerUserIds.Clear();
break;
}
});
multiplayerClient.SetupGet(c => c.CurrentMatchPlayingUserIds)
.Returns(() => multiplayerUserIds);
spectatorClient.SetupGet(c => c.WatchedUserStates)
.Returns(() => watchedUserStates);
}
