diff --git a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
index ad92016cd0..0d0a139a8a 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
@@ -41,10 +41,10 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         private readonly BindableBool distanceSnapToggle = new BindableBool(true) { Description = "Distance Snap" };
 
-        protected override IEnumerable<BindableBool> Toggles => new[]
+        protected override IEnumerable<Bindable<bool>> Toggles => base.Toggles.Concat(new[]
         {
             distanceSnapToggle
-        };
+        });
 
         private BindableList<HitObject> selectedHitObjects;
 
diff --git a/osu.Game.Rulesets.Taiko/Edit/TaikoSelectionHandler.cs b/osu.Game.Rulesets.Taiko/Edit/TaikoSelectionHandler.cs
index 40565048c2..a3ecf7ed95 100644
--- a/osu.Game.Rulesets.Taiko/Edit/TaikoSelectionHandler.cs
+++ b/osu.Game.Rulesets.Taiko/Edit/TaikoSelectionHandler.cs
@@ -1,9 +1,10 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
@@ -14,75 +15,80 @@ namespace osu.Game.Rulesets.Taiko.Edit
 {
     public class TaikoSelectionHandler : SelectionHandler
     {
+        private readonly Bindable<TernaryState> selectionRimState = new Bindable<TernaryState>();
+        private readonly Bindable<TernaryState> selectionStrongState = new Bindable<TernaryState>();
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            selectionStrongState.ValueChanged += state =>
+            {
+                switch (state.NewValue)
+                {
+                    case TernaryState.False:
+                        SetStrongState(false);
+                        break;
+
+                    case TernaryState.True:
+                        SetStrongState(true);
+                        break;
+                }
+            };
+
+            selectionRimState.ValueChanged += state =>
+            {
+                switch (state.NewValue)
+                {
+                    case TernaryState.False:
+                        SetRimState(false);
+                        break;
+
+                    case TernaryState.True:
+                        SetRimState(true);
+                        break;
+                }
+            };
+        }
+
+        public void SetStrongState(bool state)
+        {
+            var hits = SelectedHitObjects.OfType<Hit>();
+
+            ChangeHandler.BeginChange();
+
+            foreach (var h in hits)
+                h.IsStrong = state;
+
+            ChangeHandler.EndChange();
+        }
+
+        public void SetRimState(bool state)
+        {
+            var hits = SelectedHitObjects.OfType<Hit>();
+
+            ChangeHandler.BeginChange();
+
+            foreach (var h in hits)
+                h.Type = state ? HitType.Rim : HitType.Centre;
+
+            ChangeHandler.EndChange();
+        }
+
         protected override IEnumerable<MenuItem> GetContextMenuItemsForSelection(IEnumerable<SelectionBlueprint> selection)
         {
             if (selection.All(s => s.HitObject is Hit))
-            {
-                var hits = selection.Select(s => s.HitObject).OfType<Hit>();
-
-                yield return new TernaryStateMenuItem("Rim", action: state =>
-                {
-                    ChangeHandler.BeginChange();
-
-                    foreach (var h in hits)
-                    {
-                        switch (state)
-                        {
-                            case TernaryState.True:
-                                h.Type = HitType.Rim;
-                                break;
-
-                            case TernaryState.False:
-                                h.Type = HitType.Centre;
-                                break;
-                        }
-                    }
-
-                    ChangeHandler.EndChange();
-                })
-                {
-                    State = { Value = getTernaryState(hits, h => h.Type == HitType.Rim) }
-                };
-            }
+                yield return new TernaryStateMenuItem("Rim") { State = { BindTarget = selectionRimState } };
 
             if (selection.All(s => s.HitObject is TaikoHitObject))
-            {
-                var hits = selection.Select(s => s.HitObject).OfType<TaikoHitObject>();
-
-                yield return new TernaryStateMenuItem("Strong", action: state =>
-                {
-                    ChangeHandler.BeginChange();
-
-                    foreach (var h in hits)
-                    {
-                        switch (state)
-                        {
-                            case TernaryState.True:
-                                h.IsStrong = true;
-                                break;
-
-                            case TernaryState.False:
-                                h.IsStrong = false;
-                                break;
-                        }
-
-                        EditorBeatmap?.UpdateHitObject(h);
-                    }
-
-                    ChangeHandler.EndChange();
-                })
-                {
-                    State = { Value = getTernaryState(hits, h => h.IsStrong) }
-                };
-            }
+                yield return new TernaryStateMenuItem("Strong") { State = { BindTarget = selectionStrongState } };
         }
 
-        private TernaryState getTernaryState<T>(IEnumerable<T> selection, Func<T, bool> func)
+        protected override void UpdateTernaryStates()
         {
-            if (selection.Any(func))
-                return selection.All(func) ? TernaryState.True : TernaryState.Indeterminate;
+            base.UpdateTernaryStates();
 
-            return TernaryState.False;
+            selectionRimState.Value = GetStateFromSelection(SelectedHitObjects.OfType<Hit>(), h => h.Type == HitType.Rim);
+            selectionStrongState.Value = GetStateFromSelection(SelectedHitObjects.OfType<TaikoHitObject>(), h => h.IsStrong);
         }
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableHit.cs b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableHit.cs
index 92ae7e0fd3..3a6eaa83db 100644
--- a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableHit.cs
+++ b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableHit.cs
@@ -36,35 +36,64 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
         private bool pressHandledThisFrame;
 
-        private Bindable<HitType> type;
+        private readonly Bindable<HitType> type;
 
         public DrawableHit(Hit hit)
             : base(hit)
         {
+            type = HitObject.TypeBindable.GetBoundCopy();
             FillMode = FillMode.Fit;
+
+            updateActionsFromType();
         }
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            type = HitObject.TypeBindable.GetBoundCopy();
             type.BindValueChanged(_ =>
             {
-                updateType();
+                updateActionsFromType();
+
+                // will overwrite samples, should only be called on change.
+                updateSamplesFromTypeChange();
+
                 RecreatePieces();
             });
-
-            updateType();
         }
 
-        private void updateType()
+        private HitSampleInfo[] getRimSamples() => HitObject.Samples.Where(s => s.Name == HitSampleInfo.HIT_CLAP || s.Name == HitSampleInfo.HIT_WHISTLE).ToArray();
+
+        protected override void LoadSamples()
+        {
+            base.LoadSamples();
+
+            type.Value = getRimSamples().Any() ? HitType.Rim : HitType.Centre;
+        }
+
+        private void updateSamplesFromTypeChange()
+        {
+            var rimSamples = getRimSamples();
+
+            bool isRimType = HitObject.Type == HitType.Rim;
+
+            if (isRimType != rimSamples.Any())
+            {
+                if (isRimType)
+                    HitObject.Samples.Add(new HitSampleInfo { Name = HitSampleInfo.HIT_CLAP });
+                else
+                {
+                    foreach (var sample in rimSamples)
+                        HitObject.Samples.Remove(sample);
+                }
+            }
+        }
+
+        private void updateActionsFromType()
         {
             HitActions =
                 HitObject.Type == HitType.Centre
                     ? new[] { TaikoAction.LeftCentre, TaikoAction.RightCentre }
                     : new[] { TaikoAction.LeftRim, TaikoAction.RightRim };
-
-            RecreatePieces();
         }
 
         protected override SkinnableDrawable CreateMainPiece() => HitObject.Type == HitType.Centre
diff --git a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs
index 929cf8a937..9cd23383c4 100644
--- a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs
+++ b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs
@@ -1,19 +1,19 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Graphics;
-using osu.Framework.Input.Bindings;
-using osu.Game.Rulesets.Objects.Drawables;
-using osuTK;
-using System.Linq;
-using osu.Game.Audio;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
+using osu.Framework.Input.Bindings;
+using osu.Game.Audio;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Skinning;
+using osuTK;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
@@ -120,7 +120,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         protected Vector2 BaseSize;
         protected SkinnableDrawable MainPiece;
 
-        private Bindable<bool> isStrong;
+        private readonly Bindable<bool> isStrong;
 
         private readonly Container<DrawableStrongNestedHit> strongHitContainer;
 
@@ -128,6 +128,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             : base(hitObject)
         {
             HitObject = hitObject;
+            isStrong = HitObject.IsStrongBindable.GetBoundCopy();
 
             Anchor = Anchor.CentreLeft;
             Origin = Anchor.Custom;
@@ -140,8 +141,40 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         [BackgroundDependencyLoader]
         private void load()
         {
-            isStrong = HitObject.IsStrongBindable.GetBoundCopy();
-            isStrong.BindValueChanged(_ => RecreatePieces(), true);
+            isStrong.BindValueChanged(_ =>
+            {
+                // will overwrite samples, should only be called on change.
+                updateSamplesFromStrong();
+
+                RecreatePieces();
+            });
+
+            RecreatePieces();
+        }
+
+        private HitSampleInfo[] getStrongSamples() => HitObject.Samples.Where(s => s.Name == HitSampleInfo.HIT_FINISH).ToArray();
+
+        protected override void LoadSamples()
+        {
+            base.LoadSamples();
+
+            isStrong.Value = getStrongSamples().Any();
+        }
+
+        private void updateSamplesFromStrong()
+        {
+            var strongSamples = getStrongSamples();
+
+            if (isStrong.Value != strongSamples.Any())
+            {
+                if (isStrong.Value)
+                    HitObject.Samples.Add(new HitSampleInfo { Name = HitSampleInfo.HIT_FINISH });
+                else
+                {
+                    foreach (var sample in strongSamples)
+                        HitObject.Samples.Remove(sample);
+                }
+            }
         }
 
         protected virtual void RecreatePieces()
diff --git a/osu.Game/Graphics/UserInterfaceV2/LabelledTextBox.cs b/osu.Game/Graphics/UserInterfaceV2/LabelledTextBox.cs
index 72d25a7836..4aeda74be8 100644
--- a/osu.Game/Graphics/UserInterfaceV2/LabelledTextBox.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/LabelledTextBox.cs
@@ -46,6 +46,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
 
         protected virtual OsuTextBox CreateTextBox() => new OsuTextBox
         {
+            CommitOnFocusLost = true,
             Anchor = Anchor.Centre,
             Origin = Anchor.Centre,
             RelativeSizeAxes = Axes.X,
diff --git a/osu.Game/Rulesets/Edit/HitObjectComposer.cs b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
index e2a49221c0..abd8374d98 100644
--- a/osu.Game/Rulesets/Edit/HitObjectComposer.cs
+++ b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
@@ -31,6 +31,11 @@ using osuTK.Input;
 
 namespace osu.Game.Rulesets.Edit
 {
+    /// <summary>
+    /// Top level container for editor compose mode.
+    /// Responsible for providing snapping and generally gluing components together.
+    /// </summary>
+    /// <typeparam name="TObject">The base type of supported objects.</typeparam>
     [Cached(Type = typeof(IPlacementHandler))]
     public abstract class HitObjectComposer<TObject> : HitObjectComposer, IPlacementHandler
         where TObject : HitObject
@@ -165,7 +170,7 @@ namespace osu.Game.Rulesets.Edit
         /// A collection of toggles which will be displayed to the user.
         /// The display name will be decided by <see cref="Bindable{T}.Description"/>.
         /// </summary>
-        protected virtual IEnumerable<BindableBool> Toggles => Enumerable.Empty<BindableBool>();
+        protected virtual IEnumerable<Bindable<bool>> Toggles => BlueprintContainer.Toggles;
 
         /// <summary>
         /// Construct a relevant blueprint container. This will manage hitobject selection/placement input handling and display logic.
@@ -192,6 +197,9 @@ namespace osu.Game.Rulesets.Edit
 
         protected override bool OnKeyDown(KeyDownEvent e)
         {
+            if (e.ControlPressed || e.AltPressed || e.SuperPressed)
+                return false;
+
             if (checkLeftToggleFromKey(e.Key, out var leftIndex))
             {
                 var item = toolboxCollection.Items.ElementAtOrDefault(leftIndex);
diff --git a/osu.Game/Rulesets/Edit/PlacementBlueprint.cs b/osu.Game/Rulesets/Edit/PlacementBlueprint.cs
index 02d5955ae6..d986b71380 100644
--- a/osu.Game/Rulesets/Edit/PlacementBlueprint.cs
+++ b/osu.Game/Rulesets/Edit/PlacementBlueprint.cs
@@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Edit
         /// <summary>
         /// The <see cref="HitObject"/> that is being placed.
         /// </summary>
-        protected readonly HitObject HitObject;
+        public readonly HitObject HitObject;
 
         [Resolved(canBeNull: true)]
         protected EditorClock EditorClock { get; private set; }
diff --git a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
index 581617b567..28d3a39096 100644
--- a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
+++ b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
@@ -157,6 +157,9 @@ namespace osu.Game.Rulesets.Objects.Drawables
             updateState(ArmedState.Idle, true);
         }
 
+        /// <summary>
+        /// Invoked by the base <see cref="DrawableHitObject"/> to populate samples, once on initial load and potentially again on any change to the samples collection.
+        /// </summary>
         protected virtual void LoadSamples()
         {
             if (Samples != null)
diff --git a/osu.Game/Screens/Edit/Compose/Components/BlueprintContainer.cs b/osu.Game/Screens/Edit/Compose/Components/BlueprintContainer.cs
index d5e4b4fee5..8908520cd7 100644
--- a/osu.Game/Screens/Edit/Compose/Components/BlueprintContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/BlueprintContainer.cs
@@ -24,7 +24,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
 {
     /// <summary>
     /// A container which provides a "blueprint" display of hitobjects.
-    /// Includes selection and manipulation support via a <see cref="SelectionHandler"/>.
+    /// Includes selection and manipulation support via a <see cref="Components.SelectionHandler"/>.
     /// </summary>
     public abstract class BlueprintContainer : CompositeDrawable, IKeyBindingHandler<PlatformAction>
     {
@@ -32,7 +32,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         public Container<SelectionBlueprint> SelectionBlueprints { get; private set; }
 
-        private SelectionHandler selectionHandler;
+        protected SelectionHandler SelectionHandler { get; private set; }
 
         [Resolved(CanBeNull = true)]
         private IEditorChangeHandler changeHandler { get; set; }
@@ -41,7 +41,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         private EditorClock editorClock { get; set; }
 
         [Resolved]
-        private EditorBeatmap beatmap { get; set; }
+        protected EditorBeatmap Beatmap { get; private set; }
 
         private readonly BindableList<HitObject> selectedHitObjects = new BindableList<HitObject>();
 
@@ -56,22 +56,22 @@ namespace osu.Game.Screens.Edit.Compose.Components
         [BackgroundDependencyLoader]
         private void load()
         {
-            selectionHandler = CreateSelectionHandler();
-            selectionHandler.DeselectAll = deselectAll;
+            SelectionHandler = CreateSelectionHandler();
+            SelectionHandler.DeselectAll = deselectAll;
 
             AddRangeInternal(new[]
             {
                 DragBox = CreateDragBox(selectBlueprintsFromDragRectangle),
-                selectionHandler,
+                SelectionHandler,
                 SelectionBlueprints = CreateSelectionBlueprintContainer(),
-                selectionHandler.CreateProxy(),
+                SelectionHandler.CreateProxy(),
                 DragBox.CreateProxy().With(p => p.Depth = float.MinValue)
             });
 
-            foreach (var obj in beatmap.HitObjects)
+            foreach (var obj in Beatmap.HitObjects)
                 AddBlueprintFor(obj);
 
-            selectedHitObjects.BindTo(beatmap.SelectedHitObjects);
+            selectedHitObjects.BindTo(Beatmap.SelectedHitObjects);
             selectedHitObjects.CollectionChanged += (selectedObjects, args) =>
             {
                 switch (args.Action)
@@ -94,15 +94,15 @@ namespace osu.Game.Screens.Edit.Compose.Components
         {
             base.LoadComplete();
 
-            beatmap.HitObjectAdded += AddBlueprintFor;
-            beatmap.HitObjectRemoved += removeBlueprintFor;
+            Beatmap.HitObjectAdded += AddBlueprintFor;
+            Beatmap.HitObjectRemoved += removeBlueprintFor;
         }
 
         protected virtual Container<SelectionBlueprint> CreateSelectionBlueprintContainer() =>
             new Container<SelectionBlueprint> { RelativeSizeAxes = Axes.Both };
 
         /// <summary>
-        /// Creates a <see cref="SelectionHandler"/> which outlines <see cref="DrawableHitObject"/>s and handles movement of selections.
+        /// Creates a <see cref="Components.SelectionHandler"/> which outlines <see cref="DrawableHitObject"/>s and handles movement of selections.
         /// </summary>
         protected virtual SelectionHandler CreateSelectionHandler() => new SelectionHandler();
 
@@ -130,7 +130,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
                 return false;
 
             // store for double-click handling
-            clickedBlueprint = selectionHandler.SelectedBlueprints.FirstOrDefault(b => b.IsHovered);
+            clickedBlueprint = SelectionHandler.SelectedBlueprints.FirstOrDefault(b => b.IsHovered);
 
             // Deselection should only occur if no selected blueprints are hovered
             // A special case for when a blueprint was selected via this click is added since OnClick() may occur outside the hitobject and should not trigger deselection
@@ -147,7 +147,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
                 return false;
 
             // ensure the blueprint which was hovered for the first click is still the hovered blueprint.
-            if (clickedBlueprint == null || selectionHandler.SelectedBlueprints.FirstOrDefault(b => b.IsHovered) != clickedBlueprint)
+            if (clickedBlueprint == null || SelectionHandler.SelectedBlueprints.FirstOrDefault(b => b.IsHovered) != clickedBlueprint)
                 return false;
 
             editorClock?.SeekTo(clickedBlueprint.HitObject.StartTime);
@@ -208,7 +208,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             if (DragBox.State == Visibility.Visible)
             {
                 DragBox.Hide();
-                selectionHandler.UpdateVisibility();
+                SelectionHandler.UpdateVisibility();
             }
         }
 
@@ -217,7 +217,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             switch (e.Key)
             {
                 case Key.Escape:
-                    if (!selectionHandler.SelectedBlueprints.Any())
+                    if (!SelectionHandler.SelectedBlueprints.Any())
                         return false;
 
                     deselectAll();
@@ -271,7 +271,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             blueprint.Selected += onBlueprintSelected;
             blueprint.Deselected += onBlueprintDeselected;
 
-            if (beatmap.SelectedHitObjects.Contains(hitObject))
+            if (Beatmap.SelectedHitObjects.Contains(hitObject))
                 blueprint.Select();
 
             SelectionBlueprints.Add(blueprint);
@@ -298,14 +298,14 @@ namespace osu.Game.Screens.Edit.Compose.Components
             bool allowDeselection = e.ControlPressed && e.Button == MouseButton.Left;
 
             // Todo: This is probably incorrectly disallowing multiple selections on stacked objects
-            if (!allowDeselection && selectionHandler.SelectedBlueprints.Any(s => s.IsHovered))
+            if (!allowDeselection && SelectionHandler.SelectedBlueprints.Any(s => s.IsHovered))
                 return;
 
             foreach (SelectionBlueprint blueprint in SelectionBlueprints.AliveChildren)
             {
                 if (blueprint.IsHovered)
                 {
-                    selectionHandler.HandleSelectionRequested(blueprint, e.CurrentState);
+                    SelectionHandler.HandleSelectionRequested(blueprint, e.CurrentState);
                     clickSelectionBegan = true;
                     break;
                 }
@@ -358,23 +358,23 @@ namespace osu.Game.Screens.Edit.Compose.Components
         private void selectAll()
         {
             SelectionBlueprints.ToList().ForEach(m => m.Select());
-            selectionHandler.UpdateVisibility();
+            SelectionHandler.UpdateVisibility();
         }
 
         /// <summary>
         /// Deselects all selected <see cref="SelectionBlueprint"/>s.
         /// </summary>
-        private void deselectAll() => selectionHandler.SelectedBlueprints.ToList().ForEach(m => m.Deselect());
+        private void deselectAll() => SelectionHandler.SelectedBlueprints.ToList().ForEach(m => m.Deselect());
 
         private void onBlueprintSelected(SelectionBlueprint blueprint)
         {
-            selectionHandler.HandleSelected(blueprint);
+            SelectionHandler.HandleSelected(blueprint);
             SelectionBlueprints.ChangeChildDepth(blueprint, 1);
         }
 
         private void onBlueprintDeselected(SelectionBlueprint blueprint)
         {
-            selectionHandler.HandleDeselected(blueprint);
+            SelectionHandler.HandleDeselected(blueprint);
             SelectionBlueprints.ChangeChildDepth(blueprint, 0);
         }
 
@@ -391,16 +391,16 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// </summary>
         private void prepareSelectionMovement()
         {
-            if (!selectionHandler.SelectedBlueprints.Any())
+            if (!SelectionHandler.SelectedBlueprints.Any())
                 return;
 
             // Any selected blueprint that is hovered can begin the movement of the group, however only the earliest hitobject is used for movement
             // A special case is added for when a click selection occurred before the drag
-            if (!clickSelectionBegan && !selectionHandler.SelectedBlueprints.Any(b => b.IsHovered))
+            if (!clickSelectionBegan && !SelectionHandler.SelectedBlueprints.Any(b => b.IsHovered))
                 return;
 
             // Movement is tracked from the blueprint of the earliest hitobject, since it only makes sense to distance snap from that hitobject
-            movementBlueprint = selectionHandler.SelectedBlueprints.OrderBy(b => b.HitObject.StartTime).First();
+            movementBlueprint = SelectionHandler.SelectedBlueprints.OrderBy(b => b.HitObject.StartTime).First();
             movementBlueprintOriginalPosition = movementBlueprint.ScreenSpaceSelectionPoint; // todo: unsure if correct
         }
 
@@ -425,14 +425,14 @@ namespace osu.Game.Screens.Edit.Compose.Components
             var result = snapProvider.SnapScreenSpacePositionToValidTime(movePosition);
 
             // Move the hitobjects.
-            if (!selectionHandler.HandleMovement(new MoveSelectionEvent(movementBlueprint, result.ScreenSpacePosition)))
+            if (!SelectionHandler.HandleMovement(new MoveSelectionEvent(movementBlueprint, result.ScreenSpacePosition)))
                 return true;
 
             if (result.Time.HasValue)
             {
                 // Apply the start time at the newly snapped-to position
                 double offset = result.Time.Value - draggedObject.StartTime;
-                foreach (HitObject obj in selectionHandler.SelectedHitObjects)
+                foreach (HitObject obj in SelectionHandler.SelectedHitObjects)
                     obj.StartTime += offset;
             }
 
@@ -460,10 +460,10 @@ namespace osu.Game.Screens.Edit.Compose.Components
         {
             base.Dispose(isDisposing);
 
-            if (beatmap != null)
+            if (Beatmap != null)
             {
-                beatmap.HitObjectAdded -= AddBlueprintFor;
-                beatmap.HitObjectRemoved -= removeBlueprintFor;
+                Beatmap.HitObjectAdded -= AddBlueprintFor;
+                Beatmap.HitObjectRemoved -= removeBlueprintFor;
             }
         }
     }
diff --git a/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs b/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
index e1f311f1b8..6f66c1bd6f 100644
--- a/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input;
@@ -11,6 +12,7 @@ using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
 using osuTK;
 
 namespace osu.Game.Screens.Edit.Compose.Components
@@ -54,8 +56,38 @@ namespace osu.Game.Screens.Edit.Compose.Components
             base.LoadComplete();
 
             inputManager = GetContainingInputManager();
+
+            Beatmap.SelectedHitObjects.CollectionChanged += (_, __) => updateTogglesFromSelection();
+
+            // the updated object may be in the selection
+            Beatmap.HitObjectUpdated += _ => updateTogglesFromSelection();
+
+            NewCombo.ValueChanged += combo =>
+            {
+                if (Beatmap.SelectedHitObjects.Count > 0)
+                {
+                    SelectionHandler.SetNewCombo(combo.NewValue);
+                }
+                else if (currentPlacement != null)
+                {
+                    // update placement object from toggle
+                    if (currentPlacement.HitObject is IHasComboInformation c)
+                        c.NewCombo = combo.NewValue;
+                }
+            };
         }
 
+        private void updateTogglesFromSelection() =>
+            NewCombo.Value = Beatmap.SelectedHitObjects.OfType<IHasComboInformation>().All(c => c.NewCombo);
+
+        public readonly Bindable<bool> NewCombo = new Bindable<bool> { Description = "New Combo" };
+
+        public virtual IEnumerable<Bindable<bool>> Toggles => new[]
+        {
+            //TODO: this should only be enabled (visible?) for rulesets that provide combo-supporting HitObjects.
+            NewCombo
+        };
+
         #region Placement
 
         /// <summary>
@@ -86,7 +118,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
                 removePlacement();
 
             if (currentPlacement != null)
+            {
                 updatePlacementPosition();
+            }
         }
 
         protected sealed override SelectionBlueprint CreateBlueprintFor(HitObject hitObject)
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionHandler.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionHandler.cs
index 6e2c8bd01c..a316f34ad0 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionHandler.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionHandler.cs
@@ -4,7 +4,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Humanizer;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
@@ -35,6 +37,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
         public IEnumerable<SelectionBlueprint> SelectedBlueprints => selectedBlueprints;
         private readonly List<SelectionBlueprint> selectedBlueprints;
 
+        public int SelectedCount => selectedBlueprints.Count;
+
         public IEnumerable<HitObject> SelectedHitObjects => selectedBlueprints.Select(b => b.HitObject);
 
         private Drawable content;
@@ -59,6 +63,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
+            createStateBindables();
+
             InternalChild = content = new Container
             {
                 Children = new Drawable[]
@@ -283,7 +289,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
                 var comboInfo = h as IHasComboInformation;
 
                 if (comboInfo == null)
-                    throw new InvalidOperationException($"Tried to change combo state of a {h.GetType()}, which doesn't implement {nameof(IHasComboInformation)}");
+                    continue;
 
                 comboInfo.NewCombo = state;
                 EditorBeatmap?.UpdateHitObject(h);
@@ -308,6 +314,90 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         #endregion
 
+        #region Selection State
+
+        private readonly Bindable<TernaryState> selectionNewComboState = new Bindable<TernaryState>();
+
+        private readonly Dictionary<string, Bindable<TernaryState>> selectionSampleStates = new Dictionary<string, Bindable<TernaryState>>();
+
+        /// <summary>
+        /// Set up ternary state bindables and bind them to selection/hitobject changes (in both directions)
+        /// </summary>
+        private void createStateBindables()
+        {
+            // hit samples
+            var sampleTypes = new[] { HitSampleInfo.HIT_WHISTLE, HitSampleInfo.HIT_CLAP, HitSampleInfo.HIT_FINISH };
+
+            foreach (var sampleName in sampleTypes)
+            {
+                var bindable = new Bindable<TernaryState>
+                {
+                    Description = sampleName.Replace("hit", string.Empty).Titleize()
+                };
+
+                bindable.ValueChanged += state =>
+                {
+                    switch (state.NewValue)
+                    {
+                        case TernaryState.False:
+                            RemoveHitSample(sampleName);
+                            break;
+
+                        case TernaryState.True:
+                            AddHitSample(sampleName);
+                            break;
+                    }
+                };
+
+                selectionSampleStates[sampleName] = bindable;
+            }
+
+            // new combo
+            selectionNewComboState.ValueChanged += state =>
+            {
+                switch (state.NewValue)
+                {
+                    case TernaryState.False:
+                        SetNewCombo(false);
+                        break;
+
+                    case TernaryState.True:
+                        SetNewCombo(true);
+                        break;
+                }
+            };
+
+            // bring in updates from selection changes
+            EditorBeatmap.HitObjectUpdated += _ => UpdateTernaryStates();
+            EditorBeatmap.SelectedHitObjects.CollectionChanged += (sender, args) => UpdateTernaryStates();
+        }
+
+        /// <summary>
+        /// Called when context menu ternary states may need to be recalculated (selection changed or hitobject updated).
+        /// </summary>
+        protected virtual void UpdateTernaryStates()
+        {
+            selectionNewComboState.Value = GetStateFromSelection(SelectedHitObjects.OfType<IHasComboInformation>(), h => h.NewCombo);
+
+            foreach (var (sampleName, bindable) in selectionSampleStates)
+            {
+                bindable.Value = GetStateFromSelection(SelectedHitObjects, h => h.Samples.Any(s => s.Name == sampleName));
+            }
+        }
+
+        /// <summary>
+        /// Given a selection target and a function of truth, retrieve the correct ternary state for display.
+        /// </summary>
+        protected TernaryState GetStateFromSelection<T>(IEnumerable<T> selection, Func<T, bool> func)
+        {
+            if (selection.Any(func))
+                return selection.All(func) ? TernaryState.True : TernaryState.Indeterminate;
+
+            return TernaryState.False;
+        }
+
+        #endregion
+
         #region Context Menu
 
         public MenuItem[] ContextMenuItems
@@ -322,7 +412,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
                 items.AddRange(GetContextMenuItemsForSelection(selectedBlueprints));
 
                 if (selectedBlueprints.All(b => b.HitObject is IHasComboInformation))
-                    items.Add(createNewComboMenuItem());
+                {
+                    items.Add(new TernaryStateMenuItem("New combo") { State = { BindTarget = selectionNewComboState } });
+                }
 
                 if (selectedBlueprints.Count == 1)
                     items.AddRange(selectedBlueprints[0].ContextMenuItems);
@@ -331,12 +423,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
                 {
                     new OsuMenuItem("Sound")
                     {
-                        Items = new[]
-                        {
-                            createHitSampleMenuItem("Whistle", HitSampleInfo.HIT_WHISTLE),
-                            createHitSampleMenuItem("Clap", HitSampleInfo.HIT_CLAP),
-                            createHitSampleMenuItem("Finish", HitSampleInfo.HIT_FINISH)
-                        }
+                        Items = selectionSampleStates.Select(kvp =>
+                            new TernaryStateMenuItem(kvp.Value.Description) { State = { BindTarget = kvp.Value } }).ToArray()
                     },
                     new OsuMenuItem("Delete", MenuItemType.Destructive, deleteSelected),
                 });
@@ -353,76 +441,6 @@ namespace osu.Game.Screens.Edit.Compose.Components
         protected virtual IEnumerable<MenuItem> GetContextMenuItemsForSelection(IEnumerable<SelectionBlueprint> selection)
             => Enumerable.Empty<MenuItem>();
 
-        private MenuItem createNewComboMenuItem()
-        {
-            return new TernaryStateMenuItem("New combo", MenuItemType.Standard, setNewComboState)
-            {
-                State = { Value = getHitSampleState() }
-            };
-
-            void setNewComboState(TernaryState state)
-            {
-                switch (state)
-                {
-                    case TernaryState.False:
-                        SetNewCombo(false);
-                        break;
-
-                    case TernaryState.True:
-                        SetNewCombo(true);
-                        break;
-                }
-            }
-
-            TernaryState getHitSampleState()
-            {
-                int countExisting = selectedBlueprints.Select(b => (IHasComboInformation)b.HitObject).Count(h => h.NewCombo);
-
-                if (countExisting == 0)
-                    return TernaryState.False;
-
-                if (countExisting < SelectedHitObjects.Count())
-                    return TernaryState.Indeterminate;
-
-                return TernaryState.True;
-            }
-        }
-
-        private MenuItem createHitSampleMenuItem(string name, string sampleName)
-        {
-            return new TernaryStateMenuItem(name, MenuItemType.Standard, setHitSampleState)
-            {
-                State = { Value = getHitSampleState() }
-            };
-
-            void setHitSampleState(TernaryState state)
-            {
-                switch (state)
-                {
-                    case TernaryState.False:
-                        RemoveHitSample(sampleName);
-                        break;
-
-                    case TernaryState.True:
-                        AddHitSample(sampleName);
-                        break;
-                }
-            }
-
-            TernaryState getHitSampleState()
-            {
-                int countExisting = SelectedHitObjects.Count(h => h.Samples.Any(s => s.Name == sampleName));
-
-                if (countExisting == 0)
-                    return TernaryState.False;
-
-                if (countExisting < SelectedHitObjects.Count())
-                    return TernaryState.Indeterminate;
-
-                return TernaryState.True;
-            }
-        }
-
         #endregion
     }
 }