Public Access
444 lines
15 KiB
C#
444 lines
15 KiB
C#
#if WINDOWS
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Controls.Primitives;
|
|
using System.Windows.Input;
|
|
using System.Windows.Media;
|
|
using System.Windows.Threading;
|
|
using static MeetingAssistant.Workflow.WorkflowRulesEditorWpfTheme;
|
|
|
|
namespace MeetingAssistant.Workflow;
|
|
|
|
internal sealed class WpfWorkflowRulesEditorWindowService : IWorkflowRulesEditorWindowService
|
|
{
|
|
internal const string WindowTitle = "Meeting Summary Agent";
|
|
|
|
private readonly IServiceProvider services;
|
|
private readonly WorkflowRulesEditorMarkdownLinkResolver linkResolver;
|
|
private readonly ILogger<WpfWorkflowRulesEditorWindowService> logger;
|
|
private readonly object sync = new();
|
|
private Dispatcher? dispatcher;
|
|
private WorkflowRulesEditorWpfWindow? window;
|
|
private bool isStarted;
|
|
|
|
public WpfWorkflowRulesEditorWindowService(
|
|
IServiceProvider services,
|
|
WorkflowRulesEditorMarkdownLinkResolver linkResolver,
|
|
ILogger<WpfWorkflowRulesEditorWindowService> logger)
|
|
{
|
|
this.services = services;
|
|
this.linkResolver = linkResolver;
|
|
this.logger = logger;
|
|
}
|
|
|
|
public void Show()
|
|
{
|
|
EnsureUiThread();
|
|
dispatcher?.BeginInvoke(ShowOnUiThread);
|
|
}
|
|
|
|
private void EnsureUiThread()
|
|
{
|
|
lock (sync)
|
|
{
|
|
if (isStarted)
|
|
{
|
|
return;
|
|
}
|
|
|
|
isStarted = true;
|
|
var ready = new ManualResetEventSlim();
|
|
var thread = new Thread(() => RunApplication(ready))
|
|
{
|
|
IsBackground = true,
|
|
Name = "Meeting Assistant Settings and Logs"
|
|
};
|
|
thread.SetApartmentState(ApartmentState.STA);
|
|
thread.Start();
|
|
|
|
if (!ready.Wait(TimeSpan.FromSeconds(10)))
|
|
{
|
|
isStarted = false;
|
|
throw new TimeoutException("Settings and logs UI thread did not start.");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void RunApplication(ManualResetEventSlim ready)
|
|
{
|
|
try
|
|
{
|
|
logger.LogInformation("Settings and logs WPF thread started");
|
|
var application = new Application
|
|
{
|
|
ShutdownMode = ShutdownMode.OnExplicitShutdown
|
|
};
|
|
dispatcher = application.Dispatcher;
|
|
ready.Set();
|
|
application.Run();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
logger.LogError(exception, "Settings and logs WPF thread failed");
|
|
ready.Set();
|
|
}
|
|
finally
|
|
{
|
|
lock (sync)
|
|
{
|
|
dispatcher = null;
|
|
window = null;
|
|
isStarted = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ShowOnUiThread()
|
|
{
|
|
try
|
|
{
|
|
window ??= new WorkflowRulesEditorWpfWindow(
|
|
services.GetRequiredService<WorkflowRulesEditorChatViewModel>(),
|
|
linkResolver,
|
|
() => window = null);
|
|
window.Show();
|
|
if (window.WindowState == WindowState.Minimized)
|
|
{
|
|
window.WindowState = WindowState.Normal;
|
|
}
|
|
|
|
window.Activate();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
logger.LogError(exception, "Settings and logs WPF window failed");
|
|
}
|
|
}
|
|
}
|
|
|
|
internal sealed class WorkflowRulesEditorWpfWindow : Window
|
|
{
|
|
private readonly WorkflowRulesEditorChatViewModel viewModel;
|
|
private readonly WorkflowRulesEditorMarkdownLinkResolver linkResolver;
|
|
private readonly Action closed;
|
|
private readonly StackPanel conversationPanel = new() { Orientation = Orientation.Vertical };
|
|
private readonly ScrollViewer conversationScroll = new();
|
|
private readonly Border inputFrame = new();
|
|
private readonly TextBox input = new();
|
|
private readonly TextBlock inputPlaceholder = new();
|
|
private readonly Button sendButton = new();
|
|
private readonly EventHandler changedHandler;
|
|
|
|
public WorkflowRulesEditorWpfWindow(
|
|
WorkflowRulesEditorChatViewModel viewModel,
|
|
WorkflowRulesEditorMarkdownLinkResolver linkResolver,
|
|
Action closed)
|
|
{
|
|
this.viewModel = viewModel;
|
|
this.linkResolver = linkResolver;
|
|
this.closed = closed;
|
|
changedHandler = (_, _) => RequestRender();
|
|
this.viewModel.Changed += changedHandler;
|
|
|
|
Title = WpfWorkflowRulesEditorWindowService.WindowTitle;
|
|
Width = 840;
|
|
Height = 760;
|
|
MinWidth = 520;
|
|
MinHeight = 460;
|
|
Background = WindowBackground;
|
|
Content = CreateLayout();
|
|
|
|
var iconPath = Path.Combine(AppContext.BaseDirectory, "Assets", "meeting-assistant.ico");
|
|
if (File.Exists(iconPath))
|
|
{
|
|
Icon = System.Windows.Media.Imaging.BitmapFrame.Create(new Uri(iconPath));
|
|
}
|
|
|
|
Closed += (_, _) =>
|
|
{
|
|
viewModel.Changed -= changedHandler;
|
|
closed();
|
|
};
|
|
|
|
ConfigureInput();
|
|
Render();
|
|
}
|
|
|
|
private UIElement CreateLayout()
|
|
{
|
|
var root = new Grid
|
|
{
|
|
Margin = new Thickness(12)
|
|
};
|
|
root.RowDefinitions.Add(new RowDefinition { Height = new GridLength(1, GridUnitType.Star) });
|
|
root.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
|
|
|
|
conversationScroll.Content = conversationPanel;
|
|
conversationScroll.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
|
|
conversationScroll.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
|
|
conversationScroll.Padding = new Thickness(0, 0, 4, 0);
|
|
Grid.SetRow(conversationScroll, 0);
|
|
root.Children.Add(conversationScroll);
|
|
|
|
var inputRow = new Grid { Margin = new Thickness(0, 10, 0, 0) };
|
|
inputRow.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
|
|
inputRow.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
|
|
Grid.SetRow(inputRow, 1);
|
|
|
|
Grid.SetColumn(inputFrame, 0);
|
|
inputRow.Children.Add(inputFrame);
|
|
Grid.SetColumn(sendButton, 1);
|
|
inputRow.Children.Add(sendButton);
|
|
root.Children.Add(inputRow);
|
|
|
|
return root;
|
|
}
|
|
|
|
private void ConfigureInput()
|
|
{
|
|
input.AcceptsReturn = true;
|
|
input.TextWrapping = TextWrapping.Wrap;
|
|
input.MinHeight = 86;
|
|
input.MaxHeight = 124;
|
|
input.Padding = new Thickness(12, 9, 12, 9);
|
|
input.Background = Brushes.Transparent;
|
|
input.Foreground = PrimaryText;
|
|
input.BorderThickness = new Thickness(0);
|
|
input.CaretBrush = PrimaryText;
|
|
input.FontSize = 14;
|
|
input.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
|
|
input.TextChanged += (_, _) =>
|
|
{
|
|
viewModel.Draft = input.Text;
|
|
inputPlaceholder.Visibility = string.IsNullOrEmpty(input.Text)
|
|
? Visibility.Visible
|
|
: Visibility.Collapsed;
|
|
};
|
|
input.PreviewKeyDown += OnInputPreviewKeyDown;
|
|
input.GotKeyboardFocus += (_, _) => inputFrame.BorderBrush = InputFocusedBorder;
|
|
input.LostKeyboardFocus += (_, _) => inputFrame.BorderBrush = InputBorder;
|
|
|
|
inputPlaceholder.Text = "ask me what I can do for you";
|
|
inputPlaceholder.Foreground = MutedText;
|
|
inputPlaceholder.Margin = new Thickness(13, 9, 13, 9);
|
|
inputPlaceholder.IsHitTestVisible = false;
|
|
|
|
var inputGrid = new Grid();
|
|
inputGrid.Children.Add(input);
|
|
inputGrid.Children.Add(inputPlaceholder);
|
|
inputFrame.Child = inputGrid;
|
|
inputFrame.Margin = new Thickness(0, 0, 10, 0);
|
|
inputFrame.Background = InputBackground;
|
|
inputFrame.BorderBrush = InputBorder;
|
|
inputFrame.BorderThickness = new Thickness(1);
|
|
inputFrame.CornerRadius = new CornerRadius(7);
|
|
|
|
sendButton.Content = "Send";
|
|
sendButton.Width = 104;
|
|
sendButton.MinHeight = 86;
|
|
sendButton.Background = ButtonBackground;
|
|
sendButton.Foreground = PrimaryText;
|
|
sendButton.BorderBrush = InputBorder;
|
|
sendButton.BorderThickness = new Thickness(1);
|
|
sendButton.FontWeight = FontWeights.SemiBold;
|
|
sendButton.Cursor = Cursors.Hand;
|
|
sendButton.Style = CreateSendButtonStyle();
|
|
sendButton.Click += async (_, _) => await SendAsync();
|
|
}
|
|
|
|
private async void OnInputPreviewKeyDown(object sender, KeyEventArgs args)
|
|
{
|
|
if (IsEnterKey(args) && Keyboard.Modifiers.HasFlag(ModifierKeys.Shift) is false)
|
|
{
|
|
args.Handled = true;
|
|
await SendAsync();
|
|
}
|
|
}
|
|
|
|
private static bool IsEnterKey(KeyEventArgs args)
|
|
{
|
|
return args.Key is Key.Enter or Key.Return ||
|
|
args.SystemKey is Key.Enter or Key.Return ||
|
|
args.ImeProcessedKey is Key.Enter or Key.Return;
|
|
}
|
|
|
|
private async Task SendAsync()
|
|
{
|
|
var sendTask = viewModel.SendAsync();
|
|
input.Text = viewModel.Draft;
|
|
await sendTask;
|
|
}
|
|
|
|
private void RequestRender()
|
|
{
|
|
if (Dispatcher.CheckAccess())
|
|
{
|
|
Render();
|
|
return;
|
|
}
|
|
|
|
Dispatcher.BeginInvoke(Render);
|
|
}
|
|
|
|
private void Render()
|
|
{
|
|
var shouldAutoScroll = WorkflowRulesEditorScrollPolicy.ShouldAutoScroll(
|
|
conversationScroll.VerticalOffset,
|
|
conversationScroll.ViewportHeight,
|
|
conversationPanel.ActualHeight);
|
|
|
|
conversationPanel.Children.Clear();
|
|
foreach (var item in viewModel.Messages)
|
|
{
|
|
conversationPanel.Children.Add(item.Kind == WorkflowRulesEditorConversationItemKind.Activity
|
|
? CreateActivityExpander(item)
|
|
: CreateMessageCard(item.Message!));
|
|
}
|
|
|
|
if (viewModel.IsThinking)
|
|
{
|
|
foreach (var activity in viewModel.ActivityMessages)
|
|
{
|
|
conversationPanel.Children.Add(CreateActivityLine(activity));
|
|
}
|
|
|
|
conversationPanel.Children.Add(CreateActivityLine(viewModel.ActivityMessage));
|
|
}
|
|
|
|
sendButton.IsEnabled = !viewModel.IsThinking;
|
|
sendButton.Cursor = sendButton.IsEnabled ? Cursors.Hand : Cursors.Arrow;
|
|
if (shouldAutoScroll)
|
|
{
|
|
Dispatcher.BeginInvoke(DispatcherPriority.ContextIdle, ScrollConversationToBottom);
|
|
Dispatcher.BeginInvoke(DispatcherPriority.ApplicationIdle, ScrollConversationToBottom);
|
|
}
|
|
}
|
|
|
|
private void ScrollConversationToBottom()
|
|
{
|
|
conversationScroll.ScrollToVerticalOffset(WorkflowRulesEditorScrollPolicy.GetBottomOffset(
|
|
conversationScroll.ViewportHeight,
|
|
conversationPanel.ActualHeight));
|
|
}
|
|
|
|
private UIElement CreateMessageCard(WorkflowRulesEditorChatMessage message)
|
|
{
|
|
var isUser = message.Role == WorkflowRulesEditorChatRole.User;
|
|
var cardContent = new StackPanel { Orientation = Orientation.Vertical };
|
|
cardContent.Children.Add(WorkflowRulesEditorMarkdownRenderer.CreateContent(message.Content, linkResolver));
|
|
|
|
var card = new Border
|
|
{
|
|
Padding = new Thickness(12, 9, 12, 9),
|
|
Margin = isUser ? new Thickness(42, 0, 4, 8) : new Thickness(0, 0, 42, 8),
|
|
CornerRadius = new CornerRadius(8),
|
|
BorderThickness = new Thickness(1),
|
|
BorderBrush = isUser ? UserCardBorder : AgentCardBorder,
|
|
Background = isUser ? UserCardBackground : AgentCardBackground,
|
|
Child = cardContent
|
|
};
|
|
return card;
|
|
}
|
|
|
|
private static Expander CreateActivityExpander(WorkflowRulesEditorConversationItem item)
|
|
{
|
|
var details = new StackPanel
|
|
{
|
|
Orientation = Orientation.Vertical,
|
|
Margin = new Thickness(16, 2, 4, 6)
|
|
};
|
|
|
|
foreach (var line in item.ActivityLines ?? [])
|
|
{
|
|
details.Children.Add(CreateActivityLine(line));
|
|
}
|
|
|
|
var expander = new Expander
|
|
{
|
|
Header = item.Content,
|
|
Content = details,
|
|
IsExpanded = item.IsExpanded,
|
|
Foreground = MutedText,
|
|
Background = Brushes.Transparent,
|
|
Margin = new Thickness(4, 0, 4, 8)
|
|
};
|
|
expander.Expanded += (_, _) => item.IsExpanded = true;
|
|
expander.Collapsed += (_, _) => item.IsExpanded = false;
|
|
return expander;
|
|
}
|
|
|
|
private static TextBlock CreateActivityLine(string text)
|
|
{
|
|
return new TextBlock
|
|
{
|
|
Text = text,
|
|
Foreground = MutedText,
|
|
Margin = new Thickness(4, 2, 4, 2)
|
|
};
|
|
}
|
|
|
|
private static Style CreateSendButtonStyle()
|
|
{
|
|
var style = new Style(typeof(Button));
|
|
style.Setters.Add(new Setter(Control.PaddingProperty, new Thickness(12, 0, 12, 0)));
|
|
style.Setters.Add(new Setter(Control.TemplateProperty, CreateSendButtonTemplate()));
|
|
|
|
style.Triggers.Add(new Trigger
|
|
{
|
|
Property = UIElement.IsMouseOverProperty,
|
|
Value = true,
|
|
Setters =
|
|
{
|
|
new Setter(Control.BackgroundProperty, ButtonHoverBackground)
|
|
}
|
|
});
|
|
style.Triggers.Add(new Trigger
|
|
{
|
|
Property = ButtonBase.IsPressedProperty,
|
|
Value = true,
|
|
Setters =
|
|
{
|
|
new Setter(Control.BackgroundProperty, ButtonPressedBackground)
|
|
}
|
|
});
|
|
style.Triggers.Add(new Trigger
|
|
{
|
|
Property = UIElement.IsEnabledProperty,
|
|
Value = false,
|
|
Setters =
|
|
{
|
|
new Setter(Control.BackgroundProperty, DisabledButtonBackground),
|
|
new Setter(Control.BorderBrushProperty, DisabledButtonBorder),
|
|
new Setter(Control.ForegroundProperty, DisabledText),
|
|
new Setter(UIElement.OpacityProperty, 1.0)
|
|
}
|
|
});
|
|
|
|
return style;
|
|
}
|
|
|
|
private static ControlTemplate CreateSendButtonTemplate()
|
|
{
|
|
var border = new FrameworkElementFactory(typeof(Border));
|
|
border.SetValue(Border.CornerRadiusProperty, new CornerRadius(7));
|
|
border.SetValue(Border.BackgroundProperty, new TemplateBindingExtension(Control.BackgroundProperty));
|
|
border.SetValue(Border.BorderBrushProperty, new TemplateBindingExtension(Control.BorderBrushProperty));
|
|
border.SetValue(Border.BorderThicknessProperty, new TemplateBindingExtension(Control.BorderThicknessProperty));
|
|
|
|
var content = new FrameworkElementFactory(typeof(TextBlock));
|
|
content.SetValue(FrameworkElement.HorizontalAlignmentProperty, HorizontalAlignment.Center);
|
|
content.SetValue(FrameworkElement.VerticalAlignmentProperty, VerticalAlignment.Center);
|
|
content.SetValue(TextBlock.TextProperty, new TemplateBindingExtension(ContentControl.ContentProperty));
|
|
content.SetValue(TextBlock.ForegroundProperty, new TemplateBindingExtension(Control.ForegroundProperty));
|
|
content.SetValue(TextBlock.FontWeightProperty, new TemplateBindingExtension(Control.FontWeightProperty));
|
|
border.AppendChild(content);
|
|
|
|
return new ControlTemplate(typeof(Button))
|
|
{
|
|
VisualTree = border
|
|
};
|
|
}
|
|
|
|
}
|
|
#endif
|