BrowserTabs.xaml.cs

#region Copyright

// Copyright © 2026, TeamDev. All rights reserved.
// 
// Redistribution and use in source and/or binary forms, with or without
// modification, must retain the above copyright notice and the following
// disclaimer.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#endregion

using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using DotNetBrowser.Engine;
using DotNetBrowser.Extensions.Events;
using DotNetBrowser.Extensions.Handlers;
using DotNetBrowser.Handlers;
using DotNetBrowser.Logging;
using DotNetBrowser.Net;
using DotNetBrowser.Permissions.Handlers;
using DotNetBrowser.Wpf.Dialogs;

namespace Demo.Wpf
{
    /// <inheritdoc cref="TabControl" />
    /// <summary>
    ///     Interaction logic for BrowserTabs.xaml
    /// </summary>
    public partial class BrowserTabs
    {
        private const int PaddingPerTab = 42;
        private const int DefaultPadding = 37;
        private IEngine engine;
        private RenderingMode renderingMode;

        public BrowserTabs()
        {
            InitializeComponent();
            engine = CreateEngine();
            if (engine == null)
            {
                Environment.Exit(0);
            }
            
            if (GetFirstTab() is BrowserTab tab)
            {
                tab.Browser = engine?.CreateBrowser();
                tab.RenderingModeStatus.Text = $"Mode: {renderingMode}";
            }
        }

        public void DisposeEngine()
        {
            engine?.Dispose();
        }

        private IEngine CreateEngine()
        {
            string[] arguments = Environment.GetCommandLineArgs();
            renderingMode = RenderingMode.HardwareAccelerated;
            ProprietaryFeatures proprietaryFeatures = ProprietaryFeatures.None;
            if (arguments.FirstOrDefault(arg => arg.ToLower().Contains("lightweight")) != null)
            {
                renderingMode = RenderingMode.OffScreen;
            }
            if (arguments.FirstOrDefault(arg => arg.ToLower().Contains("enable-file-log")) != null)
            {
                LoggerProvider.Instance.Level = SourceLevels.Verbose;
                LoggerProvider.Instance.FileLoggingEnabled = true;
                string logFile = $"DotNetBrowser-Wpf-{Guid.NewGuid()}.log";
                LoggerProvider.Instance.OutputFile = System.IO.Path.GetFullPath(logFile);
            }
            if (arguments.FirstOrDefault(arg => arg.ToLower().Contains("proprietary")) != null)
            {
                proprietaryFeatures = ProprietaryFeatures.Aac | ProprietaryFeatures.H264;
            }

            try
            {
                IEngine engine = EngineFactory.Create(new EngineOptions.Builder
                {
                    RenderingMode = renderingMode,
                    ProprietaryFeatures = proprietaryFeatures,
                    Schemes =
                    {
                        {Scheme.Http, new WpfInterceptRequestHandler()}
                    },
                    ChromiumSwitches = {"--force-renderer-accessibility"},
                    TouchMenuDisabled = true
                }.Build());

                engine.Profiles.Default.Network.AuthenticateHandler = new DefaultAuthenticationHandler(this);
                engine.Profiles.Default.Permissions.RequestPermissionHandler =
                    new Handler<RequestPermissionParameters,
                        RequestPermissionResponse>(p => RequestPermissionResponse.Grant());
                engine.Profiles.Default.Extensions.InstallExtensionHandler =
                    new Handler<InstallExtensionParameters, InstallExtensionResponse>(p => InstallExtensionResponse
                       .Install);
                engine.Profiles.Default.Extensions.UninstallExtensionHandler =
                    new Handler<UninstallExtensionParameters, UninstallExtensionResponse>(p => UninstallExtensionResponse
                       .Uninstall);
                engine.Disposed += (sender, args) =>
                {
                    if (args.ExitCode != 0)
                    {
                        string message = $"The Chromium engine exit code was {args.ExitCode:x8}";
                        Trace.WriteLine(message);
                        MessageBox.Show(message,
                                        "DotNetBrowser Warning", MessageBoxButton.OK,
                                        MessageBoxImage.Warning);
                    }
                };
                return engine;
            }
            catch (NoLicenseException)
            {
                StringBuilder msg = new StringBuilder();
                msg.AppendLine("Thank you for trying DotNetBrowser in WPF.")
                   .AppendLine()
                   .AppendLine("To run the demo, get the free trial license and insert it below:");
                
                return ShowLicenseDialog(msg.ToString()) ? CreateEngine() : null;
            }
            catch (InvalidLicenseException)
            {
                StringBuilder msg = new StringBuilder();
                msg.AppendLine("The license key did not work. It may have an incorrect format, or is not suitable for this DotNetBrowser version.")
                   .AppendLine()
                   .AppendLine("Please enter the license key:");

                return ShowLicenseDialog(msg.ToString()) ? CreateEngine() : null;
            }
            catch (Exception e)
            {
                Trace.WriteLine(e);
                MessageBox.Show(e.Message, "DotNetBrowser Initialization Error", MessageBoxButton.OK,
                                MessageBoxImage.Error);
                return null;
            }
        }

        private TabItem GetFirstTab() => Items[0] as TabItem;

        private bool HasTabs() => !Equals(GetFirstTab(), NewButtonTab);

        private void OnAddTabButtonClicked(object sender, RoutedEventArgs e)
        {
            BrowserTab browserTab = new BrowserTab {Browser = engine?.CreateBrowser()};
            browserTab.RenderingModeStatus.Text = $"Mode: {renderingMode}";
            browserTab.Closed += OnBrowserTabClosed;
            Items.Insert(Items.Count - 1, browserTab);
            browserTab.IsSelected = true;
            UpdateTabsWidths();
        }

        private void OnBrowserTabClosed(object sender, EventArgs e)
        {
            if (sender is BrowserTab tab)
            {
                if (tab.IsSelected)
                {
                    TabItem firstTab = GetFirstTab();
                    firstTab.IsSelected = true;
                }
                Items.Remove(tab);

                if (!HasTabs())
                {
                    Application.Current.Dispatcher.Invoke(() => { Window.GetWindow(this)?.Close(); });
                }
            }
        }

        private void UpdateTabsWidths()
        {
            void UpdateTabsWidthsAction()
            {
                int browserTabsCount = Items.Count - 1;
                int paddings = browserTabsCount * PaddingPerTab + DefaultPadding;
                int browserTabWidth = ((int) ActualWidth - paddings)
                                      / browserTabsCount;

                browserTabWidth = browserTabWidth > 0 ? browserTabWidth : 0;

                foreach (TabItem tab in Items)
                {
                    if (tab is BrowserTab browserTab)
                    {
                        browserTab.Title.Width = browserTabWidth;
                    }
                }
            }

            Application.Current.Dispatcher.BeginInvoke((Action) UpdateTabsWidthsAction);
        }

        private bool ShowLicenseDialog(string message)
        {
            LicenseDialog dialog = new LicenseDialog(message);
            bool? result = dialog.ShowDialog();

            if (!result.HasValue || !result.Value)
            {
                return false;
            }

            string license = dialog.inputBox.Text;
            if (!string.IsNullOrWhiteSpace(license))
            {
                string directory = Path.GetDirectoryName(typeof(MainWindow).Assembly.Location);
                string path = Path.Combine(directory, "dotnetbrowser.license");
                File.WriteAllText(Path.GetFullPath(path), license);
                return true;
            }

            return false;
        }
    }
}