WPF

1. Read the question carefully
2. Understand that English isn't everyone's first language so be lenient of bad spelling and grammar
3. If a question is poorly phrased then either ask for clarification, ignore it, or mark it down. Insults are not welcome
4. If the question is inappropriate then click the 'vote to remove message' button

1. Choose the correct forum for your message. Posting a VB.NET question in the C++ forum will end in tears.
   
   
2. Be specific! Don't ask "can someone send me the code to create an application that does 'X'. Pinpoint exactly what it is you need help with.
   
   
3. Keep the subject line brief, but descriptive. eg "File Serialization problem"
   
   
4. Keep the question as brief as possible. If you have to include code, include the smallest snippet of code you can.
   
   
5. Be careful when including code that you haven't made a typo. Typing mistakes can become the focal point instead of the actual question you asked.
   
   
6. Do not remove or empty a message if others have replied. Keep the thread intact and available for others to search and read. If your problem was answered then edit your message and add "[Solved]" to the subject line of the original post, and cast an approval vote to the one or several answers that really helped you.
   
   
7. If you are posting source code with your question, place it inside <pre></pre> tags. We advise you also check the "Encode "<" (and other HTML) characters when pasting" checkbox before pasting anything inside the PRE block, and make sure "Use HTML in this post" check box is checked.
   
   
8. Be courteous and DON'T SHOUT. Everyone here helps because they enjoy helping others, not because it's their job.
   
   
9. Please do not post links to your question into an unrelated forum such as the lounge. It will be deleted. Likewise, do not post the same question in more than one forum.
   
   
10. Do not be abusive, offensive, inappropriate or harass anyone on the boards. Doing so will get you kicked off and banned. Play nice.
    
    
11. If you have a school or university assignment, assume that your teacher or lecturer is also reading these forums.
    
    
12. No advertising or soliciting.
    
    
13. We reserve the right to move your posts to a more appropriate forum or to delete anything deemed inappropriate or illegal.

SP.Handshake = Handshake.None;
SP.DataReceived += new SerialDataReceivedEventHandler(SP_DataReceived);

<Border Grid.Row="1"
        CornerRadius="20"
        Margin="35"
        Padding="10"
        Background="Tan"
        BorderThickness="3"
        BorderBrush="SteelBlue">

    <ScrollViewer VerticalScrollBarVisibility="Auto"
                    Background="Teal"
                    Margin="10">

        <ItemsControl ItemsSource="{Binding Backups}">

            <ItemsControl.ItemTemplate>

                <DataTemplate>

                    <Border Background="Salmon"
                            BorderBrush="Blue"
                            BorderThickness="3">

                        <StackPanel Orientation="Vertical">

                            <Rectangle Margin="5" 
                                        Width="100" 
                                        Height="100" 
                                        Fill="Yellow"
                                        HorizontalAlignment="Center"/>
                            <TextBlock Text="THIS IS A TEST"
                                        HorizontalAlignment="Center"
                                        Margin="5"/>

                        </StackPanel>

                    </Border>

                </DataTemplate>

            </ItemsControl.ItemTemplate>

            <ItemsControl.ItemsPanel>
                <ItemsPanelTemplate>
                    <WrapPanel IsItemsHost="True"/>
                </ItemsPanelTemplate>
            </ItemsControl.ItemsPanel>

        </ItemsControl>

    </ScrollViewer>

</Border>

MainWindow.xaml.cs
using Microsoft.Web.WebView2.Core;
using Microsoft.Web.WebView2.Wpf; 
public MainWindow()
        {
           InitializeComponent();
           InitializeAndNavigateAsync( url);
        }
  public async Task InitializeAndNavigateAsync(string url)
        {
            await InitializeWebViewAsync();
            await NavigateToUrlAsync(url);
        }

        private async Task InitializeWebViewAsync()
        {
            try
            {
                log.Debug($"WebView2 initialize start");
                await webView.EnsureCoreWebView2Async(null);
                log.Debug($"WebView2 initialize stop");
            }
            catch (Exception e)
            {
                log.Debug($"WebView2 initialization failed.{e.Message}");
                log.Debug($"WebView2 initialization failed.{e.StackTrace}");
            }

        }

        private async Task NavigateToUrlAsync(string url)
        {
            try
            {
                log.Debug($"WebView2 NavigateToUrlAsync start");
                webView.CoreWebView2.Navigate(url);
                log.Debug($"WebView2 NavigateToUrlAsync stop");
            }
            catch (Exception e)
            {
                log.Debug($"WebView2 NavigateToUrlAsync failed.{e.Message}");
                log.Debug($"WebView2 NavigateToUrlAsync failed.{e.StackTrace}");

            }

        }

WebView2 initialization failed.Server execution failed (Exception from HRESULT: 0x80080005 (CO_E_SERVER_EXEC_FAILURE))
2024-05-14 06:34:45.4923|DEBUG|debug|WebView2 initialization failed.   at System.Runtime.InteropServices.Marshal.ThrowExceptionForHRInternal(Int32 errorCode, IntPtr errorInfo)
   at Microsoft.Web.WebView2.Core.CoreWebView2Environment.<CreateCoreWebView2ControllerAsync>d__80.MoveNext()
--- End of stack trace from previous location where exception was thrown ---
   at System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw()
   at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task)
   at Microsoft.Web.WebView2.Wpf.WebView2.<>c__DisplayClass32_0.<<EnsureCoreWebView2Async>g__Init|0>d.MoveNext()
2024-05-14 06:34:45.4923|DEBUG|debug|WebView2 initialization failed.mscorlib

<TabItem Header="{Binding DataContext.Message, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type UserControl}}}">
                <ContentControl prism:RegionManager.RegionName="{x:Static core:RegionNames.ContentRegion}"></ContentControl>
            </TabItem>

private List<ProcessingOutputEntryEntity> _ProcesssingOutputEntries;
public List<ProcessingOutputEntryEntity> ProcesssingOutputEntries
{
    get { return _ProcesssingOutputEntries; }
    set
    {
        if (_ProcesssingOutputEntries != value)

        {
            _ProcesssingOutputEntries = value;
            RaisePropertyChanged(nameof(ProcesssingOutputEntries));
        }
    }
}

public class ProcessingOutputEntryEntity : _EntityBase
{
    private List<ColumnInfoEntity> _ProcesssingOutputColumns;
    public List<ColumnInfoEntity> ProcesssingOutputColumns
    {
        get { return _ProcesssingOutputColumns; }
        set
        {
            if (_ProcesssingOutputColumns != value)
            {
                _ProcesssingOutputColumns = value;
                RaisePropertyChanged(nameof(ProcesssingOutputColumns));
            }
        }
    }
}

public class ColumnInfoEntity : _EntityBase
{
    private string _ColumnName;
    public string ColumnName
    {
        get { return _ColumnName; }
        set
        {
            if (_ColumnName != value)
            {
                _ColumnName = value;
                RaisePropertyChanged(nameof(ColumnName));
            }
        }
    }

    private ColumnSources _ColumnSource;
    public ColumnSources ColumnSource
    {
        get { return _ColumnSource; }
        set
        {
            if (_ColumnSource != value)
            {
                _ColumnSource = value;
                RaisePropertyChanged(nameof(ColumnSource));
            }
        }
    }

    private ColumnTypes _ColumnType;
    public ColumnTypes ColumnType
    {
        get { return _ColumnType; }
        set
        {
            if (_ColumnType != value)
            {
                _ColumnType = value;
                RaisePropertyChanged(nameof(ColumnType));
            }
        }
    }

    private int _ColumnWidth;
    public int ColumnWidth
    {
        get { return _ColumnWidth; }
        set
        {
            if (_ColumnWidth != value)
            {
                _ColumnWidth = value;
                RaisePropertyChanged(nameof(ColumnWidth));
            }
        }
    }

    private string _DisplayAs;
    public string DisplayAs
    {
        get { return _DisplayAs; }
        set
        {
            if (_DisplayAs != value)
            {
                _DisplayAs = value;
                RaisePropertyChanged(nameof(DisplayAs));
            }
        }
    }

    private int _IndexPosition;
    public int IndexPosition
    {
        get { return _IndexPosition; }
        set
        {
            if (_IndexPosition != value)
            {
                _IndexPosition = value;
                RaisePropertyChanged(nameof(IndexPosition));
            }
        }
    }

    private bool _IsUserEditable = true;
    public bool IsUserEditable
    {
        get { return _IsUserEditable; }
        set
        {
            if (_IsUserEditable != value)
            {
                _IsUserEditable = value;
                RaisePropertyChanged(nameof(IsUserEditable));
            }
        }
    }

    private object _Data;
    public object Data
    {
        get { return _Data; }
        set
        {
            if (_Data != value)
            {
                _Data = value;
                RaisePropertyChanged(nameof(Data));
            }
        }
    }

    public override string ToString()
    {
        return $"{ColumnSource} {IndexPosition} {ColumnName}";
    }
}

private void WindowLoadedExecuted()
{
    // At this point, the row objects don't have an Id, so create one for each row.
    _results.ProcesssingOutputEntries.ForEach(x => x.Id = Guid.NewGuid());

    // Now, add an Id column in front of all other columns
    foreach (var entry in _results.ProcesssingOutputEntries)
    {
        var col = new ColumnInfoEntity
        {
            ColumnName = "Id",
            Data = entry.Id.ToString()
        };

        entry.ProcesssingOutputColumns.Insert(0, col);
    }

    DataColumn column = null;

    // Add data table columns using the column info objects on the first processing object
    var firstEntry = _results.ProcesssingOutputEntries.FirstOrDefault();
    foreach (var col in firstEntry.ProcesssingOutputColumns)
    {
        column = new DataColumn
        {
            DataType = Type.GetType("System.String"),
            ReadOnly = false
        };
        ColumnsDataTable.Columns.Add(column);
    }

    // Get the index positions of the AutoAdjustment and AutoPosting columns, so we can make all
    // other columns read-only
    var autoAdjColIndex = -1;
    var autoPostColIndex = -1;

    var autoAdjCol = GetProcessingOutputColumn(ColumnTypes.AutoAdjustment);

    if(autoAdjCol != null)
    {
        autoAdjColIndex = firstEntry.ProcesssingOutputColumns.IndexOf(autoAdjCol);
    }

    var autoPostCol = GetProcessingOutputColumn(ColumnTypes.AutoPosting);

    if (autoPostCol != null)
    {
        autoPostColIndex = firstEntry.ProcesssingOutputColumns.IndexOf(autoPostCol);
    }

    // Get a list of column names from the data table created above
    string[] columnNames = (from dc in ColumnsDataTable.Columns.Cast()
                            select dc.ColumnName).ToArray();

    // Create styles for the cells
    var textBoxStyle = new Style();
    textBoxStyle.Setters.Add(new Setter(TextBox.TextAlignmentProperty, TextAlignment.Right));

    var comboBoxStyle = new Style();
    comboBoxStyle.Setters.Add(new EventSetter(ComboBox.SelectionChangedEvent, new SelectionChangedEventHandler(ComboSelectionChanged)));

    // Go through each column
    int index = 0;
    foreach (string columnName in columnNames)
    {
        // Create binding
        var binding = new Binding(columnName);

        // If the column is the AutoAdjustment or AutoPosting column, add combo box columns
        // These two columns will be the right most two
        if (index == autoAdjColIndex || index == autoPostColIndex)
        {
            // Add a combo box column for it
            var col = new DataGridComboBoxColumn()
            {
                Header = firstEntry.ProcesssingOutputColumns[index].ColumnName,
                ItemsSource = new List { "Y", "N" },
                Visibility = Visibility.Visible,
                TextBinding = binding,
                IsReadOnly = false,
                CellStyle = comboBoxStyle,<br />
            };
            DataGridColumns.Add(col);
        }
        else
        {
            // Otherwise, add a read-only textbox column for it
            var col = new DataGridTextColumn()
            {
                Header = firstEntry.ProcesssingOutputColumns[index].ColumnName,
                Binding = binding,
                Visibility = Visibility.Visible,
                IsReadOnly = true,
                CellStyle = textBoxStyle
            };
            DataGridColumns.Add(col);
        }

        index++;
    }

    // Hide the first column, the Id
    //DataGridColumns.FirstOrDefault().Visibility = Visibility.Hidden;

    // Load the data into the grid
    LoadData();
}

private void LoadData()
{
    ColumnsDataTable.Clear();

    foreach (var processingEntry in _results.ProcesssingOutputEntries)
    {
        // Create a new row
        DataRow row = ColumnsDataTable.NewRow();
        ColumnsDataTable.Rows.Add(row);

        // Add each column's data
        var index = 0;
        foreach (var col in processingEntry.ProcesssingOutputColumns)
        {
            row[index] = col.Data;
            index++;
        }
    }
}

var comboBoxStyle = new Style();
comboBoxStyle.Setters.Add(new EventSetter(ComboBox.SelectionChangedEvent, new SelectionChangedEventHandler(ComboSelectionChanged)));

private void ComboSelectionChanged(object sender, SelectionChangedEventArgs e)
{
    // Find the selected row
    var comboBox = e.Source as ComboBox;
    var dataGrid = WPFTools.GetVisualParent(comboBox);
    var dataRowView = dataGrid.SelectedItem as DataRowView;

    if(dataRowView != null)
    {
        // Get the new selection from the combo box. It will be either 'Y' or 'N'
        var newSelection = e.AddedItems[0];

        // Get the row's Id
        var rowId = dataRowView.Row[0].ToString();
    }
}

public class ComboBoxWatermarkBehavior : Behavior<ComboBox>
.
.
.

public class TestControl : Label 
{
    public static readonly DependencyProperty dependencyPropertyTestInfo =
        DependencyProperty.Register("TestInfo", typeof(string), typeof(TestControl),
            new PropertyMetadata("", new PropertyChangedCallback(ChangeTestInfo)));

    public string TestInfo
    {
        get => (string)GetValue(dependencyPropertyTestInfo);
        set => SetValue(dependencyPropertyTestInfo, value);
    }
    private static void ChangeTestInfo(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var testControl = (TestControl)d;
        testControl.TestInfo = (string)e.NewValue;
    }
}

<StackPanel>
    <local:TestControl Content="TestControl" x:Name="tct" TestInfo="{Binding TestInfoView}"/>
    <Button Content="show TestInfo by Button-Click in xaml.cs" x:Name="BtnShow" Click="BtnShow_Click"/>
    <Button Content="set new TestInfo" Name="BtnNewTestInfo" Command="{Binding NewTestInfoCommand}"/>
</StackPanel>

public class MainWindowViewModel : BindableBase
{
    private int counter;
    private string _testInfoView;
    public string TestInfoView
    {
        get { return _testInfoView; }
        set { SetProperty(ref _testInfoView, value); }
    }
    public DelegateCommand NewTestInfoCommand { get; }
    public MainWindowViewModel()
    {
        NewTestInfoCommand = new DelegateCommand(OnNewTestInfoCommand);
        TestInfoView = "Info from ctor";
    }
    private void OnNewTestInfoCommand()
    {
        string newInfo = $"Info No. {++counter}";
        Debug.WriteLine($"{MethodBase.GetCurrentMethod().Name}: {nameof(TestInfoView)}=«{TestInfoView}» -> «{newInfo}»");
        TestInfoView = newInfo;
    }
}

private void BtnShow_Click(object sender, RoutedEventArgs e)
{
   Debug.WriteLine($"{MethodBase.GetCurrentMethod().Name}: {nameof(tct.TestInfo)}={tct.TestInfo}");
}

<!Tab Item Header Template>
<DataTemplate x:Key="CustomHeaderTemplate">

    <DockPanel LastChildFill="True">

        <TextBlock Text="{Binding FileName}"
                   VerticalAlignment="Center"
                   FontSize="14"/>

        <Button Command="{Binding DataContext.CloseTabCommand, RelativeSource={RelativeSource AncestorType={x:Type Window}}}"
                CommandParameter="{Binding}"
                VerticalAlignment="Center"
                Height="22"
                Width="22"
                Background="SteelBlue"
                Margin="3,0,0,0">

            <Path Data="M1,9 L9,1 M1,1 L9,9"
                  Stroke="White"
                  StrokeThickness="2" />

        </Button>

    </DockPanel>

</DataTemplate>

<!Tab Item Style>
<Style TargetType="TabItem">

    <Setter Property="ContextMenu">
        <Setter.Value>
            <ContextMenu DataContext="{Binding Path=PlacementTarget.DataContext, RelativeSource={RelativeSource Self}}" >

                <MenuItem Header="Close Tab"
                          Command="{Binding Source={StaticResource Proxy}, Path=Data.CloseTabCommand}"
                          CommandParameter="{Binding}"/>

                <MenuItem Header="Close All Tabs"
                          Command="{Binding Source={StaticResource Proxy}, Path=Data.CloseAllTabsCommand}"
                          CommandParameter="{Binding}"/>

                <MenuItem Header="Close All But This"
                          Command="{Binding Source={StaticResource Proxy}, Path=Data.CloseAllButThisTabCommand}"
                          CommandParameter="{Binding}"/>
            </ContextMenu>

        </Setter.Value>
    </Setter>

</Style>