gramps
0fdd9d5faf
The brand exemption for the universal blur put a BrandLogoOverlay above the blur host while the canvas ItemsControl kept drawing the same element, so two logos sat on top of each other. - The canvas presenter for a brand logo is collapsed: BrandLogoOverlay is the only render, and it now carries the element's Opacity so the canvas copy is not missed. - Hit-testing follows the eye: a click inside the logo's bounds selects the logo, because it is the topmost layer in the compositor too. Without that you saw the logo on top and grabbed the webcam underneath it. - SelectedLayerPreviewHitTestingTests updated to the new contract (collapsed presenter, logo wins its bounds, list selection still works). 3 tests pass; Release 0 warnings.
840 lines
34 KiB
C#
840 lines
34 KiB
C#
using System;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Input;
|
|
using System.Windows.Media;
|
|
using System.Windows.Media.Effects;
|
|
using System.Windows.Media.Animation;
|
|
using System.Windows.Shapes;
|
|
using System.Windows.Threading;
|
|
using ytLive.Helpers;
|
|
using ytLive.Models;
|
|
using ytLive.ViewModels;
|
|
|
|
namespace ytLive.Controls;
|
|
|
|
public partial class PreviewPane : UserControl
|
|
{
|
|
private bool _isDraggingOverlay;
|
|
private bool _isResizing;
|
|
private bool _isZoomDragging;
|
|
private Point _grabOffset;
|
|
private double _resizeAspect;
|
|
|
|
private readonly System.Collections.Generic.Dictionary<string, Storyboard> _activeBorderAnimations =
|
|
new();
|
|
|
|
private DispatcherTimer? _socialGlowTimer;
|
|
private double _socialGlowAngle;
|
|
|
|
public PreviewPane()
|
|
{
|
|
InitializeComponent();
|
|
DataContextChanged += PreviewPane_DataContextChanged;
|
|
OverlayElements.ItemContainerGenerator.StatusChanged += (_, _) => UpdateSelectedLayerZOrder();
|
|
}
|
|
|
|
private void PreviewPane_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
|
|
{
|
|
if (e.OldValue is MainViewModel oldVm)
|
|
{
|
|
oldVm.PropertyChanged -= ViewModel_PropertyChanged;
|
|
oldVm.PreviewTransition -= PlayPreviewTransition;
|
|
}
|
|
if (e.NewValue is MainViewModel newVm)
|
|
{
|
|
newVm.PropertyChanged += ViewModel_PropertyChanged;
|
|
newVm.PreviewTransition += PlayPreviewTransition;
|
|
UpdateZoomBox();
|
|
UpdateSelectedLayerZOrder();
|
|
HookBlurPreview();
|
|
}
|
|
}
|
|
|
|
/// <summary>Animates the outgoing picture away over the new scene: a fade for Fade and Move,
|
|
/// a right-to-left shrink for Wipe. Cut plays nothing.</summary>
|
|
private void PlayPreviewTransition(ytLive.Services.TransitionType type, double milliseconds)
|
|
{
|
|
TransitionOverlay.BeginAnimation(System.Windows.UIElement.OpacityProperty, null);
|
|
TransitionOverlay.Clip = null;
|
|
if (type == ytLive.Services.TransitionType.Cut || milliseconds <= 0)
|
|
{
|
|
TransitionOverlay.Visibility = Visibility.Collapsed;
|
|
return;
|
|
}
|
|
|
|
var snapshot = new System.Windows.Media.Imaging.RenderTargetBitmap(1920, 1080, 96, 96,
|
|
System.Windows.Media.PixelFormats.Pbgra32);
|
|
snapshot.Render(PreviewCanvas);
|
|
TransitionOverlay.Source = snapshot;
|
|
TransitionOverlay.Opacity = 1;
|
|
TransitionOverlay.Visibility = Visibility.Visible;
|
|
var duration = TimeSpan.FromMilliseconds(milliseconds);
|
|
|
|
if (type == ytLive.Services.TransitionType.Wipe)
|
|
{
|
|
var clip = new System.Windows.Media.RectangleGeometry(new Rect(0, 0, 1920, 1080));
|
|
TransitionOverlay.Clip = clip;
|
|
var reveal = new System.Windows.Media.Animation.RectAnimation(new Rect(0, 0, 0, 1080), duration)
|
|
{
|
|
FillBehavior = System.Windows.Media.Animation.FillBehavior.Stop,
|
|
};
|
|
reveal.Completed += (_, _) => TransitionOverlay.Visibility = Visibility.Collapsed;
|
|
clip.BeginAnimation(System.Windows.Media.RectangleGeometry.RectProperty, reveal);
|
|
}
|
|
else
|
|
{
|
|
var fade = new System.Windows.Media.Animation.DoubleAnimation(1, 0, duration)
|
|
{
|
|
FillBehavior = System.Windows.Media.Animation.FillBehavior.Stop,
|
|
};
|
|
fade.Completed += (_, _) => TransitionOverlay.Visibility = Visibility.Collapsed;
|
|
TransitionOverlay.BeginAnimation(System.Windows.UIElement.OpacityProperty, fade);
|
|
}
|
|
}
|
|
|
|
private void ViewModel_PropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
|
|
{
|
|
if (e.PropertyName == nameof(MainViewModel.SelectedElement))
|
|
UpdateSelectedLayerZOrder();
|
|
if (e.PropertyName == nameof(MainViewModel.IsZoomActive) || e.PropertyName == nameof(MainViewModel.ZoomState) || e.PropertyName == nameof(MainViewModel.ZoomShape))
|
|
{
|
|
UpdateZoomBox();
|
|
}
|
|
}
|
|
|
|
private void UpdateSelectedLayerZOrder()
|
|
{
|
|
var selected = (DataContext as MainViewModel)?.SelectedElement;
|
|
if (selected != null && !IsDraggableElement(selected))
|
|
selected = null;
|
|
|
|
for (var i = 0; i < OverlayElements.Items.Count; i++)
|
|
{
|
|
if (OverlayElements.ItemContainerGenerator.ContainerFromIndex(i) is UIElement container)
|
|
Panel.SetZIndex(container, ReferenceEquals(OverlayElements.Items[i], selected) ? 1 : 0);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// Static images and the webcam share the move/resize/selection behavior.
|
|
public static bool IsDraggableElement(SceneElement element)
|
|
=> element.IsDraggable;
|
|
|
|
public void UpdateSelectionOverlay(bool selected)
|
|
{
|
|
SelectionOverlay.Visibility = selected ? Visibility.Visible : Visibility.Collapsed;
|
|
}
|
|
|
|
// ─── Clicking inside the preview / pull-out drawer (used by the window's
|
|
// Window_PreviewMouseLeftButtonDown deselection logic) ───
|
|
public bool IsClickInsidePreview(DependencyObject original)
|
|
=> IsDescendantOf(original, PreviewGrid);
|
|
|
|
public bool IsClickInsideDrawer(DependencyObject original)
|
|
=> IsDescendantOf(original, TextPullOutHost);
|
|
|
|
private static bool IsDescendantOf(DependencyObject? child, DependencyObject ancestor)
|
|
{
|
|
while (child != null && !ReferenceEquals(child, ancestor))
|
|
{
|
|
child = child is Visual or System.Windows.Media.Media3D.Visual3D
|
|
? VisualTreeHelper.GetParent(child)
|
|
: LogicalTreeHelper.GetParent(child);
|
|
}
|
|
return child != null;
|
|
}
|
|
|
|
// ─── Audio meters + TRAX + socials (ROW 2 of the preview pane) ───
|
|
private void VolumeSlider_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
|
|
{
|
|
if (sender is Slider slider)
|
|
SetSliderValueFromClick(slider, e);
|
|
if (sender is FrameworkElement { DataContext: MainViewModel vm })
|
|
vm.SetVolumeAdjusting(true);
|
|
}
|
|
|
|
private void VolumeSlider_PreviewMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
|
|
{
|
|
if (sender is FrameworkElement { DataContext: MainViewModel vm })
|
|
vm.SetVolumeAdjusting(false);
|
|
}
|
|
|
|
private void VolumeSlider_LostMouseCapture(object sender, MouseEventArgs e)
|
|
{
|
|
if (sender is FrameworkElement { DataContext: MainViewModel vm })
|
|
vm.SetVolumeAdjusting(false);
|
|
}
|
|
|
|
private void GameVolumeSlider_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
|
|
{
|
|
if (sender is Slider slider)
|
|
SetSliderValueFromClick(slider, e);
|
|
if (sender is FrameworkElement { DataContext: MainViewModel vm })
|
|
vm.SetGameVolumeAdjusting(true);
|
|
}
|
|
|
|
private void GameVolumeSlider_PreviewMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
|
|
{
|
|
if (sender is FrameworkElement { DataContext: MainViewModel vm })
|
|
vm.SetGameVolumeAdjusting(false);
|
|
}
|
|
|
|
private void GameVolumeSlider_LostMouseCapture(object sender, MouseEventArgs e)
|
|
{
|
|
if (sender is FrameworkElement { DataContext: MainViewModel vm })
|
|
vm.SetGameVolumeAdjusting(false);
|
|
}
|
|
|
|
private static void SetSliderValueFromClick(Slider slider, MouseButtonEventArgs e)
|
|
{
|
|
if (FindParent<System.Windows.Controls.Primitives.Thumb>(e.OriginalSource as Visual) != null)
|
|
return;
|
|
var track = slider.Template.FindName("PART_Track", slider) as System.Windows.Controls.Primitives.Track;
|
|
if (track == null) return;
|
|
var pos = e.GetPosition(track);
|
|
var fraction = Math.Clamp(pos.X / track.RenderSize.Width, 0, 1);
|
|
slider.Value = slider.Minimum + fraction * (slider.Maximum - slider.Minimum);
|
|
e.Handled = true;
|
|
}
|
|
|
|
private static T? FindParent<T>(Visual? visual) where T : Visual
|
|
{
|
|
while (visual != null)
|
|
{
|
|
if (visual is T match) return match;
|
|
visual = VisualTreeHelper.GetParent(visual) as Visual;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
private void GameSpeaker_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
|
|
{
|
|
if (sender is FrameworkElement { DataContext: MainViewModel vm })
|
|
{
|
|
vm.ToggleGameMuteCommand.Execute(null);
|
|
}
|
|
}
|
|
|
|
// TRAX (TASK 9): left-click toggles play/pause (picks a track when none is
|
|
// loaded); right-click always opens the picker. The picker is the OS file
|
|
// dialog — the "never the OS viewer" rule covers the preview, not pickers.
|
|
|
|
|
|
// ─── Webcam / background context menus (right-click on overlay elements) ───
|
|
private void WebcamMenu_ChangeWebcam(object sender, RoutedEventArgs e)
|
|
=> (DataContext as MainViewModel)?.ChangeWebcamCommand.Execute(null);
|
|
|
|
private void WebcamMenu_SetBorderAnimation(object sender, RoutedEventArgs e)
|
|
{
|
|
if (sender is not MenuItem { DataContext: SceneElement element, Tag: string tag }
|
|
|| !Enum.TryParse<BorderAnimation>(tag, out var animation))
|
|
return;
|
|
|
|
element.BorderAnimation = animation;
|
|
|
|
StopBorderAnimation(element.Id);
|
|
|
|
if (animation == BorderAnimation.None) return;
|
|
|
|
var shape = FindBorderShape(sender as DependencyObject);
|
|
if (shape == null) return;
|
|
|
|
var sb = CreateBorderAnimation(animation, shape);
|
|
if (sb == null) return;
|
|
|
|
sb.Freeze();
|
|
_activeBorderAnimations[element.Id] = sb;
|
|
shape.BeginAnimation(Shape.OpacityProperty, null);
|
|
Storyboard.SetTarget(sb, shape);
|
|
sb.Begin();
|
|
}
|
|
|
|
private void StopBorderAnimation(string elementId)
|
|
{
|
|
if (_activeBorderAnimations.TryGetValue(elementId, out var old))
|
|
{
|
|
old.Stop();
|
|
_activeBorderAnimations.Remove(elementId);
|
|
}
|
|
}
|
|
|
|
private static Shape? FindBorderShape(DependencyObject? start)
|
|
{
|
|
var current = start;
|
|
while (current != null)
|
|
{
|
|
if (current is ContextMenu cm && cm.PlacementTarget is FrameworkElement target)
|
|
{
|
|
for (var i = 0; i < VisualTreeHelper.GetChildrenCount(target); i++)
|
|
{
|
|
var child = VisualTreeHelper.GetChild(target, i);
|
|
if (child is Shape s && (s is Rectangle or Ellipse) && !s.IsHitTestVisible)
|
|
return s;
|
|
}
|
|
return null;
|
|
}
|
|
current = VisualTreeHelper.GetParent(current);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static Storyboard? CreateBorderAnimation(BorderAnimation animation, Shape shape)
|
|
{
|
|
var sb = new Storyboard();
|
|
switch (animation)
|
|
{
|
|
case BorderAnimation.Pulse:
|
|
AddDoubleAnimation(sb, Shape.OpacityProperty, 1.0, 0.3, TimeSpan.FromSeconds(0.8), true);
|
|
break;
|
|
case BorderAnimation.Glow:
|
|
AddDoubleAnimation(sb, Shape.OpacityProperty, 1.0, 0.5, TimeSpan.FromSeconds(1.2), true);
|
|
break;
|
|
case BorderAnimation.Shimmer:
|
|
AddDoubleAnimation(sb, Shape.OpacityProperty, 1.0, 0.15, TimeSpan.FromSeconds(0.5), true);
|
|
break;
|
|
case BorderAnimation.Electricity:
|
|
AddDoubleAnimation(sb, Shape.OpacityProperty, 1.0, 0.2, TimeSpan.FromSeconds(0.1), true);
|
|
break;
|
|
case BorderAnimation.Sparkles:
|
|
AddDoubleAnimation(sb, Shape.OpacityProperty, 1.0, 0.4, TimeSpan.FromSeconds(0.3), true);
|
|
break;
|
|
case BorderAnimation.MarchingAnts:
|
|
shape.StrokeDashArray = new DoubleCollection { 4, 2 };
|
|
AddDoubleAnimation(sb, Shape.StrokeDashOffsetProperty, 0, -20, TimeSpan.FromSeconds(0.8), false);
|
|
break;
|
|
case BorderAnimation.Chase:
|
|
shape.StrokeDashArray = new DoubleCollection { 8, 4 };
|
|
AddDoubleAnimation(sb, Shape.StrokeDashOffsetProperty, 0, -30, TimeSpan.FromSeconds(1.5), false);
|
|
break;
|
|
case BorderAnimation.Rainbow:
|
|
if (shape.Stroke is SolidColorBrush brush)
|
|
{
|
|
var frozen = brush.IsFrozen;
|
|
if (frozen) brush = brush.Clone();
|
|
shape.Stroke = brush;
|
|
var colorAnim = new ColorAnimationUsingKeyFrames
|
|
{
|
|
Duration = new Duration(TimeSpan.FromSeconds(3)),
|
|
RepeatBehavior = RepeatBehavior.Forever
|
|
};
|
|
colorAnim.KeyFrames.Add(new LinearColorKeyFrame(Colors.Red, KeyTime.FromTimeSpan(TimeSpan.Zero)));
|
|
colorAnim.KeyFrames.Add(new LinearColorKeyFrame(Colors.Yellow, KeyTime.FromTimeSpan(TimeSpan.FromSeconds(0.5))));
|
|
colorAnim.KeyFrames.Add(new LinearColorKeyFrame(Colors.Green, KeyTime.FromTimeSpan(TimeSpan.FromSeconds(1))));
|
|
colorAnim.KeyFrames.Add(new LinearColorKeyFrame(Colors.DodgerBlue, KeyTime.FromTimeSpan(TimeSpan.FromSeconds(1.5))));
|
|
colorAnim.KeyFrames.Add(new LinearColorKeyFrame(Colors.MediumPurple, KeyTime.FromTimeSpan(TimeSpan.FromSeconds(2))));
|
|
colorAnim.KeyFrames.Add(new LinearColorKeyFrame(Colors.Red, KeyTime.FromTimeSpan(TimeSpan.FromSeconds(2.5))));
|
|
Storyboard.SetTargetProperty(colorAnim, new PropertyPath("(Shape.Stroke).(SolidColorBrush.Color)"));
|
|
sb.Children.Add(colorAnim);
|
|
}
|
|
break;
|
|
default:
|
|
return null;
|
|
}
|
|
return sb.Children.Count > 0 ? sb : null;
|
|
}
|
|
|
|
private static void AddDoubleAnimation(Storyboard sb, DependencyProperty prop,
|
|
double from, double to, Duration duration, bool autoReverse)
|
|
{
|
|
var anim = new DoubleAnimation(from, to, duration)
|
|
{
|
|
AutoReverse = autoReverse,
|
|
RepeatBehavior = RepeatBehavior.Forever
|
|
};
|
|
Storyboard.SetTargetProperty(anim, new PropertyPath(prop));
|
|
sb.Children.Add(anim);
|
|
}
|
|
|
|
/// <summary>The border-colour submenu is BUILT from the palette on open: the list of
|
|
/// offered colours lives once, in <see cref="BorderColorPalette"/> (TASK 63's rule —
|
|
/// a picker never carries its own copy). The generated rows inherit this menu's
|
|
/// DataContext (the <see cref="SceneElement"/>), so the click handler is unchanged.</summary>
|
|
private void WebcamBorderColorMenu_SubmenuOpened(object sender, RoutedEventArgs e)
|
|
{
|
|
if (sender is not MenuItem { DataContext: SceneElement element } menu) return;
|
|
|
|
menu.Items.Clear();
|
|
var none = new MenuItem { Header = "None", Tag = string.Empty, IsCheckable = true,
|
|
IsChecked = string.IsNullOrEmpty(element.BorderColor) };
|
|
none.Click += WebcamMenu_SetBorderColor;
|
|
menu.Items.Add(none);
|
|
|
|
foreach (var colour in BorderColorPalette.All)
|
|
{
|
|
var row = new MenuItem
|
|
{
|
|
Header = colour.ToString(),
|
|
Tag = colour.Hex,
|
|
IsCheckable = true,
|
|
IsChecked = string.Equals(element.BorderColor, colour.Hex, StringComparison.OrdinalIgnoreCase),
|
|
};
|
|
row.Click += WebcamMenu_SetBorderColor;
|
|
menu.Items.Add(row);
|
|
}
|
|
}
|
|
|
|
private void WebcamMenu_SetBorderColor(object sender, RoutedEventArgs e)
|
|
{
|
|
if (sender is MenuItem { DataContext: SceneElement element, Tag: string color })
|
|
element.BorderColor = color;
|
|
}
|
|
|
|
private void WebcamMenu_HideInScene(object sender, RoutedEventArgs e)
|
|
{
|
|
if (sender is MenuItem { DataContext: SceneElement element })
|
|
element.IsVisible = false;
|
|
}
|
|
|
|
private void WebcamMenu_Remove(object sender, RoutedEventArgs e)
|
|
{
|
|
if (sender is MenuItem { DataContext: SceneElement element })
|
|
(DataContext as MainViewModel)?.RemoveSourceCommand.Execute(element);
|
|
}
|
|
|
|
// ─── Social bar: click toggles top ⇄ bottom. KISS — the drag variant was
|
|
// unusable for shaky hands (jitter around the direction deadzone), so the bar
|
|
// rides on {Binding SocialBarTop} alone and a click flips it. ───
|
|
private void SocialBar_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
|
|
{
|
|
(DataContext as MainViewModel)?.ToggleSocialBarPosition();
|
|
e.Handled = true;
|
|
}
|
|
|
|
/// <summary>Is this canvas point inside the social bar? It is a full-width strip at the top or
|
|
/// bottom of the frame and it consumes its own click, so the preview's tunnelling handler has
|
|
/// to step aside (see <c>Preview_MouseLeftButtonDown</c>).</summary>
|
|
private bool IsOverSocialBar(Point canvasPoint)
|
|
{
|
|
if (DataContext is not MainViewModel { SocialBarVisible: true }) return false;
|
|
if (SocialBarElement.ActualHeight <= 0) return false;
|
|
|
|
var topLeft = SocialBarElement.TranslatePoint(new Point(0, 0), CanvasGrid);
|
|
return new Rect(topLeft, SocialBarElement.RenderSize).Contains(canvasPoint);
|
|
}
|
|
|
|
private void SocialsButton_MouseEnter(object sender, MouseEventArgs e)
|
|
{
|
|
if (SocialBarElement == null) return;
|
|
|
|
// Kick the social bar to full brightness so it's immediately visible
|
|
var effect = SocialBarElement.Effect as DropShadowEffect;
|
|
if (effect != null)
|
|
{
|
|
effect.BlurRadius = 40;
|
|
effect.Opacity = 1.0;
|
|
}
|
|
|
|
// Pulse the glow so it catches the eye
|
|
_socialGlowAngle = 0;
|
|
_socialGlowTimer?.Stop();
|
|
_socialGlowTimer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(30) };
|
|
_socialGlowTimer.Tick += SocialGlowTick;
|
|
_socialGlowTimer.Start();
|
|
}
|
|
|
|
private void SocialsButton_MouseLeave(object sender, MouseEventArgs e)
|
|
{
|
|
_socialGlowTimer?.Stop();
|
|
_socialGlowTimer = null;
|
|
|
|
if (SocialBarElement?.Effect is DropShadowEffect effect)
|
|
{
|
|
effect.BlurRadius = 18;
|
|
effect.Opacity = 0.9;
|
|
}
|
|
}
|
|
|
|
private void SocialGlowTick(object? sender, EventArgs e)
|
|
{
|
|
if (SocialBarElement?.Effect is not DropShadowEffect effect) return;
|
|
|
|
_socialGlowAngle += 0.18;
|
|
if (_socialGlowAngle > Math.PI * 2) _socialGlowAngle -= Math.PI * 2;
|
|
|
|
// Smooth sine pulse: BlurRadius 24→48, Opacity 0.7→1.0
|
|
double t = (Math.Sin(_socialGlowAngle) + 1.0) / 2.0; // 0..1
|
|
effect.BlurRadius = 24 + t * 24;
|
|
effect.Opacity = 0.7 + t * 0.3;
|
|
}
|
|
|
|
// ─── Preview: element selection / move / resize / hit-testing ───
|
|
private void Preview_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
|
|
{
|
|
var vm = DataContext as MainViewModel;
|
|
if (vm is null) return;
|
|
|
|
var grid = (Grid)sender;
|
|
var toCanvas = CanvasGrid.TransformToVisual(grid).Inverse;
|
|
var p = toCanvas.Transform(e.GetPosition(grid));
|
|
|
|
// The social bar owns its own left-click (toggle top ⇄ bottom). This handler is the
|
|
// TUNNELLING preview event, so it fires before the bar's bubbling handler: without this
|
|
// guard the bar would be unclickable in preview mode (zoom would win) and, in edit mode,
|
|
// it would drag whatever layer sat underneath it.
|
|
if (IsOverSocialBar(p)) return;
|
|
|
|
// Preview mode (EDIT off): the left button drives the zoom box — the common gesture in
|
|
// the mode where nothing is editable. Dragging it afterwards is handled by MouseMove.
|
|
if (!vm.IsEditMode)
|
|
{
|
|
vm.ToggleZoom(p.X, p.Y);
|
|
e.Handled = true;
|
|
return;
|
|
}
|
|
|
|
// Zoom freezes the layers (creator ruling 2026-11-01): while the magnifier is up, a left
|
|
// drag moves the box and NEVER picks up a layer underneath it. MouseMove owns the drag.
|
|
if (vm.IsZoomActive) return;
|
|
var selected = vm.SelectedElement;
|
|
|
|
if (selected is { } sel && IsDraggableElement(sel) && HitHandle(e.GetPosition(grid), sel))
|
|
{
|
|
vm.PushPreviewUndo();
|
|
_isResizing = true;
|
|
_resizeAspect = sel.ClipShape == ClipShape.Round ? 1 : sel.Width / Math.Max(1, sel.Height);
|
|
grid.CaptureMouse();
|
|
e.Handled = true;
|
|
return;
|
|
}
|
|
|
|
var hit = HitElementAt(vm, p);
|
|
if (hit != null)
|
|
{
|
|
vm.SelectedElement = hit;
|
|
// One snapshot per gesture: pushing inside the move loop would fill the stack with
|
|
// a hundred one-pixel steps.
|
|
vm.PushPreviewUndo();
|
|
_isDraggingOverlay = true;
|
|
_grabOffset = new Point(p.X - hit.X, p.Y - hit.Y);
|
|
grid.CaptureMouse();
|
|
e.Handled = true;
|
|
return;
|
|
}
|
|
|
|
vm.SelectedElement = null;
|
|
}
|
|
|
|
private void Preview_MouseMove(object sender, MouseEventArgs e)
|
|
{
|
|
var vm = DataContext as MainViewModel;
|
|
if (vm is null) return;
|
|
var grid = (Grid)sender;
|
|
var toCanvas = CanvasGrid.TransformToVisual(grid).Inverse;
|
|
var p = toCanvas.Transform(e.GetPosition(grid));
|
|
|
|
if (e.LeftButton == MouseButtonState.Pressed && vm.IsZoomActive)
|
|
{
|
|
if (!_isZoomDragging)
|
|
{
|
|
vm.StartZoomMove(p.X, p.Y);
|
|
_isZoomDragging = true;
|
|
grid.CaptureMouse();
|
|
}
|
|
else
|
|
{
|
|
vm.UpdateZoomMove(p.X, p.Y);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (!vm.IsEditMode) return;
|
|
if (!_isDraggingOverlay && !_isResizing) return;
|
|
|
|
var selected = vm.SelectedElement;
|
|
if (selected == null)
|
|
{
|
|
EndPreviewDrag(grid);
|
|
return;
|
|
}
|
|
|
|
if (_isDraggingOverlay)
|
|
{
|
|
// TASK 57: under the vertical tier the camera snaps into the
|
|
// cropped band (one of six spots) instead of free-floating over
|
|
// the master — outside the band it is not in the stream at all.
|
|
if (vm.IsVerticalTier && selected is WebcamSceneConfig verticalCam)
|
|
{
|
|
vm.MoveWebcamInVerticalTier(verticalCam, p.X - _grabOffset.X, p.Y - _grabOffset.Y);
|
|
}
|
|
else
|
|
{
|
|
var minX = -(selected.Width - 20);
|
|
var maxX = 1920 - 20;
|
|
var minY = -(selected.Height - 20);
|
|
var maxY = 1080 - 20;
|
|
selected.X = Math.Clamp(p.X - _grabOffset.X, Math.Min(minX, maxX), Math.Max(minX, maxX));
|
|
selected.Y = Math.Clamp(p.Y - _grabOffset.Y, Math.Min(minY, maxY), Math.Max(minY, maxY));
|
|
}
|
|
}
|
|
else if (_isResizing)
|
|
{
|
|
var isWebcam = selected is WebcamSceneConfig;
|
|
var isRound = selected.ClipShape == ClipShape.Round;
|
|
var proportional = isRound || Keyboard.Modifiers.HasFlag(ModifierKeys.Shift);
|
|
var maxW = isWebcam ? MainViewModel.MaxWebcamWidthFor(vm.StagedScene?.Name) : 1920;
|
|
var maxH = isWebcam ? MainViewModel.MaxWebcamHeightFor(vm.StagedScene?.Name) : 1080;
|
|
var newW = Math.Clamp(p.X - selected.X, 32, maxW);
|
|
var newH = proportional ? newW / _resizeAspect : Math.Clamp(p.Y - selected.Y, 32, maxH);
|
|
if (proportional && newH > maxH)
|
|
{
|
|
newH = maxH;
|
|
newW = newH * _resizeAspect;
|
|
}
|
|
selected.Width = newW;
|
|
selected.Height = newH;
|
|
|
|
// TASK 57: inside the vertical band the size snaps (the Chat
|
|
// camera has two sizes: the small tile or one whole area) and the
|
|
// camera ends up on its spot.
|
|
if (vm.IsVerticalTier && selected is WebcamSceneConfig verticalCam)
|
|
vm.ResizeWebcamInVerticalTier(verticalCam, newW, newH);
|
|
}
|
|
}
|
|
|
|
private void Preview_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
|
|
{
|
|
if (_isZoomDragging && DataContext is MainViewModel vm)
|
|
{
|
|
vm.EndZoomMove();
|
|
_isZoomDragging = false;
|
|
((Grid)sender).ReleaseMouseCapture();
|
|
e.Handled = true;
|
|
return;
|
|
}
|
|
EndPreviewDrag((Grid)sender);
|
|
}
|
|
|
|
private void Preview_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
|
|
{
|
|
// Right-click = the context menu, in both modes (creator ruling 2026-11-01).
|
|
// Ctrl+right-click = the zoom box, EDIT MODE ONLY: the creator asked for no two-handed
|
|
// chords while live or recording, so the preview swallows Ctrl+right-click instead of
|
|
// letting it fall through to the menu. Returning without Handled is what lets WPF's
|
|
// ContextMenuService open the menu under the cursor.
|
|
var vm = DataContext as MainViewModel;
|
|
if (vm is null) return;
|
|
if ((Keyboard.Modifiers & ModifierKeys.Control) == 0) return;
|
|
|
|
if (!vm.IsEditMode)
|
|
{
|
|
e.Handled = true;
|
|
return;
|
|
}
|
|
|
|
var grid = (Grid)sender;
|
|
var toCanvas = CanvasGrid.TransformToVisual(grid).Inverse;
|
|
var p = toCanvas.Transform(e.GetPosition(grid));
|
|
vm.ToggleZoom(p.X, p.Y);
|
|
e.Handled = true;
|
|
}
|
|
|
|
private void Preview_MouseRightButtonUp(object sender, MouseButtonEventArgs e)
|
|
{
|
|
if (_isZoomDragging)
|
|
{
|
|
var grid = (Grid)sender;
|
|
grid.ReleaseMouseCapture();
|
|
_isZoomDragging = false;
|
|
if (DataContext is MainViewModel vm) vm.EndZoomMove();
|
|
e.Handled = true;
|
|
return;
|
|
}
|
|
|
|
// WPF's PopupControlService opens a context menu on right-button-UP, not down — so
|
|
// handling the Down event alone still let a menu appear under a Ctrl+right-click (found
|
|
// by the creator in edit mode, 2026-11-01). Swallow the Up event too, in both modes:
|
|
// Down decides the action, Up must not undo that decision.
|
|
if ((Keyboard.Modifiers & ModifierKeys.Control) != 0)
|
|
e.Handled = true;
|
|
}
|
|
|
|
private void EndPreviewDrag(Grid grid)
|
|
{
|
|
if (_isDraggingOverlay || _isResizing || _isZoomDragging)
|
|
grid.ReleaseMouseCapture();
|
|
_isDraggingOverlay = false;
|
|
_isResizing = false;
|
|
_isZoomDragging = false;
|
|
if (DataContext is MainViewModel vm) vm.EndZoomMove();
|
|
}
|
|
|
|
private bool HitHandle(Point mouseScreen, SceneElement element)
|
|
{
|
|
var corner = CanvasGrid.TransformToVisual(PreviewGrid).Transform(new Point(element.X + element.Width, element.Y + element.Height));
|
|
return Math.Abs(mouseScreen.X - corner.X) <= 20 && Math.Abs(mouseScreen.Y - corner.Y) <= 20;
|
|
}
|
|
|
|
internal SceneElement? HitElementAt(MainViewModel vm, Point p)
|
|
{
|
|
var scene = vm.StagedScene;
|
|
if (scene == null) return null;
|
|
|
|
// A layer selected from the list temporarily wins both preview stacking and hit-testing;
|
|
// the scene's persistent element order remains unchanged.
|
|
if (vm.SelectedElement is { } selected && IsHitTestable(selected) && Contains(selected, p))
|
|
return selected;
|
|
|
|
// The brand logo is drawn ABOVE everything (the compositor blits it after the blur group,
|
|
// and the preview renders it in BrandLogoOverlay), so a click inside it must select it —
|
|
// otherwise you see the logo on top and grab the webcam underneath it.
|
|
var brand = vm.StagedBrandLogo;
|
|
if (brand is { IsVisible: true } && Contains(brand, p))
|
|
return brand;
|
|
|
|
for (var i = scene.Elements.Count - 1; i >= 0; i--)
|
|
{
|
|
var element = scene.Elements[i];
|
|
if (IsHitTestable(element) && Contains(element, p))
|
|
return element;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static bool IsHitTestable(SceneElement element)
|
|
=> IsDraggableElement(element)
|
|
&& element is not Source { IsEnabled: false }
|
|
&& element is not WebcamSceneConfig { IsVisible: false };
|
|
|
|
private static bool Contains(SceneElement element, Point point)
|
|
=> point.X >= element.X && point.X <= element.X + element.Width
|
|
&& point.Y >= element.Y && point.Y <= element.Y + element.Height;
|
|
|
|
private void UpdateZoomBox()
|
|
{
|
|
if (DataContext is not MainViewModel vm) return;
|
|
if (vm.IsZoomActive && ZoomVisualBrush != null)
|
|
{
|
|
// The preview mirrors the output zoom layer: sample the WHOLE composed
|
|
// preview (CanvasGrid = backdrop + every element layer — the same all-layer
|
|
// source the output compositor magnifies) at the FIXED capture window (the
|
|
// box/2 region centred on the click) → 2x via Stretch=Fill. Moving the box
|
|
// only moves the ZoomBox element; the Viewbox stays glued to the capture.
|
|
ZoomVisualBrush.Visual = CanvasGrid;
|
|
ZoomVisualBrush.Viewbox = new Rect(
|
|
vm.ZoomState.CaptureX,
|
|
vm.ZoomState.CaptureY,
|
|
vm.ZoomState.Width / 2,
|
|
vm.ZoomState.Height / 2);
|
|
ZoomVisualBrush.ViewboxUnits = BrushMappingMode.Absolute;
|
|
if (vm.ZoomShape == Models.ZoomShape.Circle)
|
|
{
|
|
ZoomCircleOutline.Visibility = Visibility.Visible;
|
|
ZoomRectOutline.Visibility = Visibility.Collapsed;
|
|
ZoomBox.Clip = new EllipseGeometry(new Rect(0, 0, vm.ZoomState.Width, vm.ZoomState.Height));
|
|
}
|
|
else
|
|
{
|
|
ZoomCircleOutline.Visibility = Visibility.Collapsed;
|
|
ZoomRectOutline.Visibility = Visibility.Visible;
|
|
ZoomBox.Clip = null;
|
|
}
|
|
}
|
|
else if (!vm.IsZoomActive && ZoomVisualBrush != null && ReferenceEquals(ZoomVisualBrush.Visual, CanvasGrid))
|
|
{
|
|
ZoomVisualBrush.Visual = null;
|
|
}
|
|
}
|
|
|
|
/// <summary>Rail settings tab (creator ruling 2026-11-01): a left click opens the Settings
|
|
/// DRAWER immediately, exactly like the other rail tabs — no menu, no modal.</summary>
|
|
private void SettingsTab_Click(object sender, MouseButtonEventArgs e)
|
|
{
|
|
if (DataContext is MainViewModel vm) vm.ToggleSettingsDrawer();
|
|
e.Handled = true;
|
|
}
|
|
|
|
// ─── Privacy blur preview (2026-11-01) ───
|
|
// The editor has to show the blur it is about to bake into the output, and the blur is
|
|
// UNIVERSAL: it covers every layer, webcam and chat included. Each blur becomes a
|
|
// rectangle/ellipse filled with a VisualBrush of the whole CanvasGrid sampled at that rect,
|
|
// with a BlurEffect at the same strength the compositor uses. The host canvas is a SIBLING
|
|
// above CanvasGrid, which is what stops the brush from sampling itself.
|
|
private MainViewModel? _blurVm;
|
|
private Scene? _blurScene;
|
|
|
|
private void HookBlurPreview()
|
|
{
|
|
if (_blurVm != null) _blurVm.PropertyChanged -= BlurViewModelChanged;
|
|
_blurVm = DataContext as MainViewModel;
|
|
if (_blurVm != null) _blurVm.PropertyChanged += BlurViewModelChanged;
|
|
HookBlurScene();
|
|
}
|
|
|
|
private void BlurViewModelChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
|
|
{
|
|
if (e.PropertyName is nameof(MainViewModel.StagedScene)) HookBlurScene();
|
|
else if (e.PropertyName is nameof(MainViewModel.ActiveBackgroundImage)
|
|
or nameof(MainViewModel.BackgroundImage)) RebuildBlurPreview();
|
|
}
|
|
|
|
private void HookBlurScene()
|
|
{
|
|
if (_blurScene != null)
|
|
{
|
|
_blurScene.Elements.CollectionChanged -= BlurElementsChanged;
|
|
foreach (var element in _blurScene.Elements) element.PropertyChanged -= BlurElementChanged;
|
|
}
|
|
|
|
_blurScene = _blurVm?.StagedScene;
|
|
|
|
if (_blurScene != null)
|
|
{
|
|
_blurScene.Elements.CollectionChanged += BlurElementsChanged;
|
|
foreach (var element in _blurScene.Elements) element.PropertyChanged += BlurElementChanged;
|
|
}
|
|
|
|
RebuildBlurPreview();
|
|
}
|
|
|
|
private void BlurElementsChanged(object? sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
|
|
{
|
|
foreach (var element in e.OldItems?.OfType<SceneElement>() ?? System.Linq.Enumerable.Empty<SceneElement>())
|
|
element.PropertyChanged -= BlurElementChanged;
|
|
foreach (var element in e.NewItems?.OfType<SceneElement>() ?? System.Linq.Enumerable.Empty<SceneElement>())
|
|
element.PropertyChanged += BlurElementChanged;
|
|
RebuildBlurPreview();
|
|
}
|
|
|
|
private void BlurElementChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
|
|
{
|
|
if (sender is Source { IsBlur: true }) RebuildBlurPreview();
|
|
}
|
|
|
|
/// <summary>Rebuild one overlay shape per visible blur. Cheap by design: a handful of shapes,
|
|
/// and the VisualBrush samples the live backdrop so the preview keeps moving underneath.</summary>
|
|
private void RebuildBlurPreview()
|
|
{
|
|
if (BlurPreviewHost == null) return;
|
|
BlurPreviewHost.Children.Clear();
|
|
if (_blurScene == null) return;
|
|
|
|
foreach (var blur in _blurScene.Elements.OfType<Source>()
|
|
.Where(s => s.IsBlur && s.IsVisible && s.Width > 0 && s.Height > 0))
|
|
{
|
|
var shape = new Rectangle
|
|
{
|
|
Width = blur.Width,
|
|
Height = blur.Height,
|
|
Fill = new VisualBrush(CanvasGrid)
|
|
{
|
|
Viewbox = new Rect(blur.X, blur.Y, blur.Width, blur.Height),
|
|
ViewboxUnits = BrushMappingMode.Absolute,
|
|
Stretch = Stretch.Fill,
|
|
},
|
|
// 4..24 px at master scale, the same shape of curve the compositor's radius uses.
|
|
Effect = new BlurEffect { Radius = 4 + 20 * Math.Clamp(blur.BlurAmount, 0, 1), KernelType = KernelType.Gaussian },
|
|
};
|
|
|
|
if (blur.ClipShape == ClipShape.Round)
|
|
shape.Clip = new EllipseGeometry(new Rect(0, 0, blur.Width, blur.Height));
|
|
|
|
Canvas.SetLeft(shape, blur.X);
|
|
Canvas.SetTop(shape, blur.Y);
|
|
BlurPreviewHost.Children.Add(shape);
|
|
}
|
|
}
|
|
}
|