/////////////////////////////////////////////////////////////////////////////
// Name:        webview.cpp
// Purpose:     wxWebView sample
// Author:      Marianne Gagnon
// Copyright:   (c) 2010 Marianne Gagnon, Steven Lamerton
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"


#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#if !wxUSE_WEBVIEW_WEBKIT && !wxUSE_WEBVIEW_WEBKIT2 && \
    !wxUSE_WEBVIEW_IE && !wxUSE_WEBVIEW_EDGE && \
    !wxUSE_WEBVIEW_CHROMIUM
#error "A wxWebView backend is required by this sample"
#endif

#include "wx/artprov.h"
#include "wx/cmdline.h"
#include "wx/notifmsg.h"
#include "wx/settings.h"
#include "wx/webview.h"
#if wxUSE_WEBVIEW_CHROMIUM
#include "wx/webview_chromium.h"
#endif
#if wxUSE_WEBVIEW_IE
#include "wx/msw/webview_ie.h"
#endif
#if wxUSE_WEBVIEW_EDGE
#include "wx/msw/webview_edge.h"
#endif
#include "wx/webviewarchivehandler.h"
#include "wx/webviewfshandler.h"
#include "wx/numdlg.h"
#include "wx/infobar.h"
#include "wx/filesys.h"
#include "wx/fs_arc.h"
#include "wx/fs_mem.h"
#include "wx/stdpaths.h"
#include "wx/utils.h"
#if wxUSE_PRINTING_ARCHITECTURE
#include "wx/cmndata.h"
#include "wx/choicdlg.h"
#include "wx/filedlgcustomize.h"
#endif

#ifndef wxHAS_IMAGES_IN_RESOURCES
    #include "../sample.xpm"
#endif

#if wxUSE_STC
#include "wx/stc/stc.h"
#else
#include "wx/textctrl.h"
#endif

#include "wxlogo.xpm"

#include <map>

// This sample can be built with and without wxUSE_WEBVIEW_CHROMIUM, so we
// can't put the libraries in the project linker options and have to link them
// from here.
#if defined(_MSC_VER) && wxUSE_WEBVIEW_CHROMIUM
    #pragma comment(lib, "libcef")
    #pragma comment(lib, "libcef_dll_wrapper")
#endif

//We map menu items to their history items
using wxMenuHistoryMap = std::map<int, wxSharedPtr<wxWebViewHistoryItem>>;

class WebApp : public wxApp
{
public:
    WebApp() :
        m_url("https://www.wxwidgets.org")
    {
    }

    virtual bool OnInit() override;

#if wxUSE_CMDLINE_PARSER
    virtual void OnInitCmdLine(wxCmdLineParser& parser) override
    {
        wxApp::OnInitCmdLine(parser);

        parser.AddParam("URL to open",
                        wxCMD_LINE_VAL_STRING,
                        wxCMD_LINE_PARAM_OPTIONAL);
    }

    virtual bool OnCmdLineParsed(wxCmdLineParser& parser) override
    {
        if ( !wxApp::OnCmdLineParsed(parser) )
            return false;

        if ( parser.GetParamCount() )
            m_url = parser.GetParam(0);

        return true;
    }
#endif // wxUSE_CMDLINE_PARSER

private:
    wxString m_url;
};

class WebFrame : public wxFrame
{
public:
    enum
    {
        Child   = 0,
        Main    = 1,
        Private = 2
    };

    enum
    {
        ID_CLEAR_BROWSING_DATA_ALL = wxID_HIGHEST + 1,
        ID_CLEAR_BROWSING_DATA_CACHE,
        ID_CLEAR_BROWSING_DATA_COOKIES,
        ID_CLEAR_BROWSING_DATA_DOM_STORAGE,
        ID_CLEAR_BROWSING_DATA_OTHER,
        ID_CLEAR_BROWSING_DATA_LAST_HOUR
    };

    WebFrame(const wxString& url, int flags = 0, wxWebViewWindowFeatures* windowFeatures = nullptr);
    virtual ~WebFrame();

    void UpdateState();
    void OnIdle(wxIdleEvent& evt);
    void OnUrl(wxCommandEvent& evt);
    void OnBack(wxCommandEvent& evt);
    void OnForward(wxCommandEvent& evt);
    void OnStop(wxCommandEvent& evt);
    void OnReload(wxCommandEvent& evt);
    void OnClearHistory(wxCommandEvent& evt);
    void OnEnableHistory(wxCommandEvent& evt);
    void OnNavigationRequest(wxWebViewEvent& evt);
    void OnNavigationComplete(wxWebViewEvent& evt);
    void OnDocumentLoaded(wxWebViewEvent& evt);
    void OnNewWindow(wxWebViewEvent& evt);
    void OnNewWindowFeatures(wxWebViewEvent& evt);
    void OnTitleChanged(wxWebViewEvent& evt);
    void OnFullScreenChanged(wxWebViewEvent& evt);
    void OnScriptMessage(wxWebViewEvent& evt);
    void OnScriptResult(wxWebViewEvent& evt);
    void OnWindowCloseRequested(wxWebViewEvent& evt);
    void OnSetPage(wxCommandEvent& evt);
    void OnViewSourceRequest(wxCommandEvent& evt);
    void OnViewTextRequest(wxCommandEvent& evt);
    void OnToolsClicked(wxCommandEvent& evt);
    void OnSetZoom(wxCommandEvent& evt);
    void OnError(wxWebViewEvent& evt);
    void OnPrint(wxCommandEvent& evt);
    void OnPrintWithSettings(wxCommandEvent& evt);
    void OnPrintToPDF(wxCommandEvent& evt);
#if wxUSE_PRINTING_ARCHITECTURE && (defined(__WXMSW__) || defined(__WXGTK__))
    void OnPrintToPDFWithSettings(wxCommandEvent& evt);
#endif
    void OnOpenPrivateWindow(wxCommandEvent& evt);
    void OnCut(wxCommandEvent& evt);
    void OnCopy(wxCommandEvent& evt);
    void OnPaste(wxCommandEvent& evt);
    void OnUndo(wxCommandEvent& evt);
    void OnRedo(wxCommandEvent& evt);
    void OnMode(wxCommandEvent& evt);
    void OnZoomLayout(wxCommandEvent& evt);
    void OnZoomCustom(wxCommandEvent& evt);
    void OnHistory(wxCommandEvent& evt);
    void OnScrollLineUp(wxCommandEvent&) { m_browser->LineUp(); }
    void OnScrollLineDown(wxCommandEvent&) { m_browser->LineDown(); }
    void OnScrollPageUp(wxCommandEvent&) { m_browser->PageUp(); }
    void OnScrollPageDown(wxCommandEvent&) { m_browser->PageDown(); }
    void RunScript(const wxString& javascript);
    void OnRunScriptString(wxCommandEvent& evt);
    void OnRunScriptInteger(wxCommandEvent& evt);
    void OnRunScriptDouble(wxCommandEvent& evt);
    void OnRunScriptBool(wxCommandEvent& evt);
    void OnRunScriptObject(wxCommandEvent& evt);
    void OnRunScriptArray(wxCommandEvent& evt);
    void OnRunScriptDOM(wxCommandEvent& evt);
    void OnRunScriptUndefined(wxCommandEvent& evt);
    void OnRunScriptNull(wxCommandEvent& evt);
    void OnRunScriptDate(wxCommandEvent& evt);
#if wxUSE_WEBVIEW_IE
    void OnRunScriptObjectWithEmulationLevel(wxCommandEvent& evt);
    void OnRunScriptDateWithEmulationLevel(wxCommandEvent& evt);
    void OnRunScriptArrayWithEmulationLevel(wxCommandEvent& evt);
#endif
    void OnRunScriptMessage(wxCommandEvent& evt);
    void OnRunScriptAsync(wxCommandEvent& evt);
    void OnRunScriptCustom(wxCommandEvent& evt);
    void OnAddUserScript(wxCommandEvent& evt);
    void OnSetCustomUserAgent(wxCommandEvent& evt);
    void OnSetProxy(wxCommandEvent& evt);
    void OnClearBrowsingData(wxCommandEvent& evt);
    void OnClearSelection(wxCommandEvent& evt);
    void OnDeleteSelection(wxCommandEvent& evt);
    void OnSelectAll(wxCommandEvent& evt);
    void OnLoadScheme(wxCommandEvent& evt);
    void OnUseMemoryFS(wxCommandEvent& evt);
    void OnLoadAdvancedHandler(wxCommandEvent& evt);
    void OnFind(wxCommandEvent& evt);
    void OnFindDone(wxCommandEvent& evt);
    void OnFindText(wxCommandEvent& evt);
    void OnFindOptions(wxCommandEvent& evt);
    void OnEnableContextMenu(wxCommandEvent& evt);
    void OnEnableDevTools(wxCommandEvent& evt);
    void OnShowDevTools(wxCommandEvent& evt);
    void OnEnableBrowserAcceleratorKeys(wxCommandEvent& evt);

private:
    // Return a special prefix for the "private" ("incognito") window titles.
    wxString GetPrivatePrefix() const
    {
        wxString prefix;
        if (m_flags & Private)
            prefix = "[Private] ";
        return prefix;
    }

    wxTextCtrl* m_url;
    wxWebView* m_browser;
    int m_flags;

    wxToolBar* m_toolbar;
    wxToolBarToolBase* m_toolbar_back;
    wxToolBarToolBase* m_toolbar_forward;
    wxToolBarToolBase* m_toolbar_stop;
    wxToolBarToolBase* m_toolbar_reload;
    wxToolBarToolBase* m_toolbar_tools;

    wxToolBarToolBase* m_find_toolbar_done;
    wxToolBarToolBase* m_find_toolbar_next;
    wxToolBarToolBase* m_find_toolbar_previous;
    wxToolBarToolBase* m_find_toolbar_options;
    wxMenuItem* m_find_toolbar_wrap;
    wxMenuItem* m_find_toolbar_highlight;
    wxMenuItem* m_find_toolbar_matchcase;
    wxMenuItem* m_find_toolbar_wholeword;

    wxMenu* m_tools_menu;
    wxMenu* m_tools_history_menu;
    wxMenuItem* m_tools_layout;
    wxMenuItem* m_tools_tiny;
    wxMenuItem* m_tools_small;
    wxMenuItem* m_tools_medium;
    wxMenuItem* m_tools_large;
    wxMenuItem* m_tools_largest;
    wxMenuItem* m_tools_custom;
    wxMenuItem* m_tools_handle_navigation;
    wxMenuItem* m_tools_handle_new_window;
    wxMenuItem* m_tools_enable_history;
    wxMenuItem* m_edit_cut;
    wxMenuItem* m_edit_copy;
    wxMenuItem* m_edit_paste;
    wxMenuItem* m_edit_undo;
    wxMenuItem* m_edit_redo;
    wxMenuItem* m_edit_mode;
    wxMenuItem* m_scroll_line_up;
    wxMenuItem* m_scroll_line_down;
    wxMenuItem* m_scroll_page_up;
    wxMenuItem* m_scroll_page_down;
    wxMenuItem* m_script_string;
    wxMenuItem* m_script_integer;
    wxMenuItem* m_script_double;
    wxMenuItem* m_script_bool;
    wxMenuItem* m_script_object;
    wxMenuItem* m_script_array;
    wxMenuItem* m_script_dom;
    wxMenuItem* m_script_undefined;
    wxMenuItem* m_script_null;
    wxMenuItem* m_script_date;
#if wxUSE_WEBVIEW_IE
    wxMenuItem* m_script_object_el;
    wxMenuItem* m_script_date_el;
    wxMenuItem* m_script_array_el;
#endif
    wxMenuItem* m_script_message;
    wxMenuItem* m_script_custom;
    wxMenuItem* m_script_async;
    wxMenuItem* m_selection_clear;
    wxMenuItem* m_selection_delete;
    wxMenuItem* m_find;
    wxMenuItem* m_context_menu;
    wxMenuItem* m_dev_tools;
    wxMenuItem* m_browser_accelerator_keys;

    wxInfoBar *m_info;
    wxStaticText* m_info_text;
    wxTextCtrl* m_find_ctrl;
    wxToolBar* m_find_toolbar;
    wxTextCtrl* m_log_textCtrl;

    wxMenuHistoryMap m_histMenuItems;
    wxString m_findText;
    int m_findFlags, m_findCount;
    long m_zoomFactor;

    // Last executed JavaScript snippet, for convenience.
    wxString m_javascript;
};

class SourceViewDialog : public wxDialog
{
public:
    SourceViewDialog(wxWindow* parent, wxString source);
};

// AdvancedWebViewHandler is a sample handler used by handler_advanced.html
// to show a sample implementation of wxWebViewHandler::StartRequest().
// see the documentation for additional details.
class AdvancedWebViewHandler: public wxWebViewHandler
{
public:
    AdvancedWebViewHandler():
        wxWebViewHandler("wxpost")
    { }

    virtual void StartRequest(const wxWebViewHandlerRequest& request,
                              wxSharedPtr<wxWebViewHandlerResponse> response) override
    {
        response->SetHeader("Access-Control-Allow-Origin", "*");
        response->SetHeader("Access-Control-Allow-Headers", "*");

        // Handle options request
        if (request.GetMethod().IsSameAs("options", false))
        {
            response->Finish("");
            return;
        }

        response->SetContentType("application/json");
        response->Finish(
            wxString::Format(
                "{\n  contentType: \"%s\",\n  method: \"%s\",\n  data: \"%s\"\n}",
                request.GetHeader("Content-Type"),
                request.GetMethod(),
                request.GetDataString()
        ));
    }
};

wxIMPLEMENT_APP(WebApp);

// ============================================================================
// implementation
// ============================================================================

bool WebApp::OnInit()
{
    if ( !wxApp::OnInit() )
        return false;

    //Required for virtual file system archive and memory support
    wxFileSystem::AddHandler(new wxArchiveFSHandler);
    wxFileSystem::AddHandler(new wxMemoryFSHandler);

    // Create the memory files
    wxImage::AddHandler(new wxPNGHandler);
    wxMemoryFSHandler::AddFile("logo.png",
        wxBitmap(wxlogo_xpm), wxBITMAP_TYPE_PNG);
    wxMemoryFSHandler::AddFile("page1.htm",
        "<html><head><title>File System Example</title>"
        "<link rel='stylesheet' type='text/css' href='memory:test.css'>"
        "</head><body><h1>Page 1</h1>"
        "<p><img src='memory:logo.png'></p>"
        "<p>Some text about <a href='memory:page2.htm'>Page 2</a>.</p></body>");
    wxMemoryFSHandler::AddFile("page2.htm",
        "<html><head><title>File System Example</title>"
        "<link rel='stylesheet' type='text/css' href='memory:test.css'>"
        "</head><body><h1>Page 2</h1>"
        "<p><a href='memory:page1.htm'>Page 1</a> was better.</p></body>");
    wxMemoryFSHandler::AddFile("test.css", "h1 {color: red;}");

    WebFrame *frame = new WebFrame(m_url, WebFrame::Main);
    frame->Show();

    return true;
}

WebFrame::WebFrame(const wxString& url, int flags, wxWebViewWindowFeatures* windowFeatures) :
    wxFrame(nullptr, wxID_ANY, "wxWebView Sample"),
    m_flags(flags)
{
    // set the frame icon
    SetIcon(wxICON(sample));
    SetTitle("wxWebView Sample");
    EnableFullScreenView(); // Enable native fullscreen API on macOS

    wxBoxSizer* topsizer = new wxBoxSizer(wxVERTICAL);

    // Create the toolbar
    m_toolbar = CreateToolBar(wxTB_TEXT);

    m_toolbar_back = m_toolbar->AddTool(wxID_ANY, _("Back"), wxArtProvider::GetBitmapBundle(wxART_GO_BACK, wxART_TOOLBAR));
    m_toolbar_forward = m_toolbar->AddTool(wxID_ANY, _("Forward"), wxArtProvider::GetBitmapBundle(wxART_GO_FORWARD, wxART_TOOLBAR));
    m_toolbar_stop = m_toolbar->AddTool(wxID_ANY, _("Stop"), wxArtProvider::GetBitmapBundle(wxART_STOP, wxART_TOOLBAR));
    m_toolbar_reload = m_toolbar->AddTool(wxID_ANY, _("Reload"), wxArtProvider::GetBitmapBundle(wxART_REFRESH, wxART_TOOLBAR));
    m_url = new wxTextCtrl(m_toolbar, wxID_ANY, "", wxDefaultPosition, FromDIP(wxSize(400, -1)), wxTE_PROCESS_ENTER);
    m_toolbar->AddControl(m_url, _("URL"));
    m_toolbar_tools = m_toolbar->AddTool(wxID_ANY, _("Menu"), wxArtProvider::GetBitmapBundle(wxART_WX_LOGO, wxART_TOOLBAR));

    m_toolbar->Realize();

    // Set find values.
    m_findFlags = wxWEBVIEW_FIND_DEFAULT;
    m_findCount = 0;

    // Create panel for find toolbar.
    wxPanel* panel = new wxPanel(this);
    topsizer->Add(panel, wxSizerFlags().Expand());

    // Create sizer for panel.
    wxBoxSizer* panel_sizer = new wxBoxSizer(wxVERTICAL);
    panel->SetSizer(panel_sizer);

    // Create the find toolbar.
    m_find_toolbar = new wxToolBar(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTB_HORIZONTAL|wxTB_TEXT|wxTB_HORZ_LAYOUT);
    m_find_toolbar->Hide();
    panel_sizer->Add(m_find_toolbar, wxSizerFlags().Expand());

    // Create find control.
    m_find_ctrl = new wxTextCtrl(m_find_toolbar, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(140,-1), wxTE_PROCESS_ENTER);


    //Find options menu
    wxMenu* findmenu = new wxMenu;
    m_find_toolbar_wrap = findmenu->AppendCheckItem(wxID_ANY,"Wrap");
    m_find_toolbar_matchcase = findmenu->AppendCheckItem(wxID_ANY,"Match Case");
    m_find_toolbar_wholeword = findmenu->AppendCheckItem(wxID_ANY,"Entire Word");
    m_find_toolbar_highlight = findmenu->AppendCheckItem(wxID_ANY,"Highlight");
    // Add find toolbar tools.
    m_find_toolbar->SetToolSeparation(7);
    m_find_toolbar_done = m_find_toolbar->AddTool(wxID_ANY, "Close", wxArtProvider::GetBitmap(wxART_CROSS_MARK));
    m_find_toolbar->AddSeparator();
    m_find_toolbar->AddControl(m_find_ctrl, "Find");
    m_find_toolbar->AddSeparator();
    m_find_toolbar_next = m_find_toolbar->AddTool(wxID_ANY, "Next", wxArtProvider::GetBitmap(wxART_GO_DOWN, wxART_TOOLBAR, wxSize(16,16)));
    m_find_toolbar_previous = m_find_toolbar->AddTool(wxID_ANY, "Previous", wxArtProvider::GetBitmap(wxART_GO_UP, wxART_TOOLBAR, wxSize(16,16)));
    m_find_toolbar->AddSeparator();
    m_find_toolbar_options = m_find_toolbar->AddTool(wxID_ANY, "Options", wxArtProvider::GetBitmap(wxART_PLUS, wxART_TOOLBAR, wxSize(16,16)), "", wxITEM_DROPDOWN);
    m_find_toolbar_options->SetDropdownMenu(findmenu);
    m_find_toolbar->Realize();

    // Create the info panel
    m_info = new wxInfoBar(this);
    topsizer->Add(m_info, wxSizerFlags().Expand());

#if wxUSE_WEBVIEW_EDGE
    // Check if a fixed version of edge is present in
    // $executable_path/edge_fixed and use it
    wxFileName edgeFixedDir(wxStandardPaths::Get().GetExecutablePath());
    edgeFixedDir.SetFullName("");
    edgeFixedDir.AppendDir("edge_fixed");
    if (edgeFixedDir.DirExists())
    {
        wxWebViewEdge::MSWSetBrowserExecutableDir(edgeFixedDir.GetFullPath());
        wxLogMessage("Using fixed edge version");
    }
#endif

    // Create the webview: WX_WEBVIEW_BACKEND environment variable allows to
    // select the backend to use if there is more than one available.
    wxString backend;
    if ( !wxGetEnv("WX_WEBVIEW_BACKEND", &backend) )
        backend = wxWebViewBackendDefault;
    // Allow specifying shorter "CEF" instead of having to type the full class
    // name.
    //
    // Note that this is more than just a minor convenience: this also ensures
    // that we reference wxWebViewBackendChromium from this file and this means
    // that MSVC linker keeps wxWebViewChromium code when using static
    // libraries while without it, it could discard it completely and it
    // wouldn't be available during run-time at all.
    else if ( backend.CmpNoCase("cef") == 0 )
        backend = wxWebViewBackendChromium;

    if ( backend != wxWebViewBackendDefault &&
            !wxWebView::IsBackendAvailable(backend) )
    {
        wxLogWarning("Requested backend \"%s\" is not available, using default "
                     "backend instead.", backend);
        backend = wxWebViewBackendDefault;
    }

    if (!windowFeatures)
    {
        wxWebViewConfiguration conf = wxWebView::NewConfiguration(backend);
        if (m_flags & Private)
        {
            if (!conf.EnablePersistentStorage(false))
            {
                wxLogWarning("Disabling persistent storage is not supported by this backend!");
                m_flags ^= Private;
            }
        }

        m_browser = wxWebView::New(conf);
    }
    else
    {
        m_browser = windowFeatures->GetChildWebView();
    }
    if ( !m_browser )
    {
        wxLogFatalError("Failed to create wxWebView object using \"%s\" backend", backend);
    }

    // With several backends the proxy can only be set before creation, so do
    // it here if the standard environment variable is defined.
    wxString proxy;
    if ( wxGetEnv("http_proxy", &proxy) )
    {
        if ( m_browser->SetProxy(proxy) )
            wxLogMessage("Using proxy \"%s\"", proxy);
        //else: error message should have been already given by wxWebView itself
    }

#ifdef __WXMAC__
    if (m_flags & Main)
    {
        // With WKWebView handlers need to be registered before creation
        m_browser->RegisterHandler(wxSharedPtr<wxWebViewHandler>(new wxWebViewArchiveHandler("wxfs")));
        m_browser->RegisterHandler(wxSharedPtr<wxWebViewHandler>(new wxWebViewFSHandler("memory")));
        m_browser->RegisterHandler(wxSharedPtr<wxWebViewHandler>(new AdvancedWebViewHandler()));
    }
#endif
    if ( !m_browser->Create(this, wxID_ANY, url) )
    {
        wxLogFatalError("Failed to create wxWebView");
    }

    topsizer->Add(m_browser, wxSizerFlags().Expand().Proportion(1));

    if (m_flags & Main)
    {
        // Setup log text control
        m_log_textCtrl = new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE | wxTE_READONLY | wxTE_RICH2);
        m_log_textCtrl->SetMinSize(FromDIP(wxSize(100, 100)));
        topsizer->Add(m_log_textCtrl, wxSizerFlags().Expand().Proportion(0));
        delete wxLog::SetActiveTarget(new wxLogTextCtrl(m_log_textCtrl));

        // Log backend information

        const auto formatVersion = [](const char* context,
                                      const wxVersionInfo& version) {
            wxString str;

            if ( version.IsOk() )
            {
                str.Printf(", %s version=%s",
                           context, version.GetNumericVersionString());

                if ( version.HasDescription() )
                    str += wxString::Format(" (%s)", version.GetDescription());
            }

            return str;
        };

        const auto versionRunTime = formatVersion("run-time", wxWebView::GetBackendVersionInfo(backend));
        const auto versionBuildTime = formatVersion("build-time", wxWebView::GetBackendVersionInfo(
            backend, wxVersionContext::BuildTime
        ));

        wxLogMessage("Backend: %s%s%s",
                     m_browser->GetClassInfo()->GetClassName(),
                     versionRunTime,
                     versionBuildTime);

        // Chromium backend can't be used immediately after creation, so wait
        // until the browser is created before calling GetUserAgent(), but we
        // can't do it unconditionally either as doing it with WebViewGTK
        // triggers https://gitlab.gnome.org/GNOME/gtk/-/issues/124 and just
        // kills the sample.
        const auto initShow = [this](){
            wxLogMessage("Web view created, user agent is \"%s\"", m_browser->GetUserAgent());

            // We need to synchronize this call with GetUserAgent() one, as
            // otherwise the results of executing JavaScript inside
            // GetUserAgent() and AddScriptMessageHandler() could arrive out of
            // order and we'd get the wrong user agent string back.
            if (!m_browser->AddScriptMessageHandler("wx"))
                wxLogError("Could not add script message handler");
        };

        if ( backend == wxWebViewBackendChromium )
        {
            m_browser->Bind(wxEVT_WEBVIEW_CREATED, [initShow](wxWebViewEvent& event) {
                initShow();

                event.Skip();
            });
        }
        else
        {
            initShow();
        }


        m_browser->Bind(wxEVT_WEBVIEW_PDF_SAVED, [](wxWebViewEvent& event) {
            if (event.IsError())
                wxLogError("Failed to save PDF to '%s'", event.GetURL());
            else
                wxLogMessage("PDF saved to '%s'", event.GetURL());
            event.Skip();
        });

        m_browser->Bind(wxEVT_WEBVIEW_BROWSING_DATA_CLEARED, [](wxWebViewEvent& event) {
            if (event.IsError())
                wxLogError("Failed to clear browsing data");
            else
                wxLogMessage("Browsing data cleared");
            event.Skip();
        });

#ifndef __WXMAC__
        //We register the wxfs:// protocol for testing purposes
        m_browser->RegisterHandler(wxSharedPtr<wxWebViewHandler>(new wxWebViewArchiveHandler("wxfs")));
        //And the memory: file system
        m_browser->RegisterHandler(wxSharedPtr<wxWebViewHandler>(new wxWebViewFSHandler("memory")));
        m_browser->RegisterHandler(wxSharedPtr<wxWebViewHandler>(new AdvancedWebViewHandler()));
#endif
    }
    else
        wxLogMessage("Created new window");

    SetSizer(topsizer);

    //Set a more sensible size for web browsing
    SetSize(FromDIP(wxSize(940, 700)));

    if (windowFeatures)
    {
        if (windowFeatures->GetSize().IsFullySpecified())
            SetSize(FromDIP(windowFeatures->GetSize()));
        if (windowFeatures->GetPosition().IsFullySpecified())
            Move(FromDIP(windowFeatures->GetPosition()));
        if (!windowFeatures->ShouldDisplayToolBar())
            m_toolbar->Hide();
        if (!windowFeatures->ShouldDisplayMenuBar())
            SetMenuBar(nullptr);
    }

    // Create the Tools menu
    m_tools_menu = new wxMenu();
    wxMenuItem* print = m_tools_menu->Append(wxID_ANY , _("Print"));
#if wxUSE_PRINTING_ARCHITECTURE
    wxMenuItem* printWithSettings = m_tools_menu->Append(wxID_ANY , _("Print with Settings..."));
#endif
    wxMenuItem* printToPDF = m_tools_menu->Append(wxID_ANY, _("Save as PDF..."));
#if wxUSE_PRINTING_ARCHITECTURE && (defined(__WXMSW__) || defined(__WXGTK__))
    wxMenuItem* printToPDFWithSettings = m_tools_menu->Append(wxID_ANY, _("Save as PDF with Settings..."));
#endif
    wxMenuItem* setPage = m_tools_menu->Append(wxID_ANY , _("Set page text"));
    wxMenuItem* viewSource = m_tools_menu->Append(wxID_ANY , _("View Source"));
    wxMenuItem* viewText = m_tools_menu->Append(wxID_ANY, _("View Text"));
    wxMenuItem* openPrivate = m_tools_menu->Append(wxID_ANY, _("Open Private Window"));
    m_tools_menu->AppendSeparator();
    m_tools_layout = m_tools_menu->AppendRadioItem(wxID_ANY, _("Use Layout Zoom"));
    m_tools_tiny = m_tools_menu->AppendRadioItem(wxID_ANY, _("Tiny"));
    m_tools_small = m_tools_menu->AppendRadioItem(wxID_ANY, _("Small"));
    m_tools_medium = m_tools_menu->AppendRadioItem(wxID_ANY, _("Medium"));
    m_tools_large = m_tools_menu->AppendRadioItem(wxID_ANY, _("Large"));
    m_tools_largest = m_tools_menu->AppendRadioItem(wxID_ANY, _("Largest"));
    m_tools_custom = m_tools_menu->AppendRadioItem(wxID_ANY, _("Custom Size"));
    m_tools_menu->AppendSeparator();
    m_tools_handle_navigation = m_tools_menu->AppendCheckItem(wxID_ANY, _("Handle Navigation"));
    m_tools_handle_new_window = m_tools_menu->AppendCheckItem(wxID_ANY, _("Handle New Windows"));
    m_tools_menu->AppendSeparator();

    //Find
    m_find = m_tools_menu->Append(wxID_ANY, _("Find"));
    m_tools_menu->AppendSeparator();

    //History menu
    m_tools_history_menu = new wxMenu();
    wxMenuItem* clearhist =  m_tools_history_menu->Append(wxID_ANY, _("Clear History"));
    m_tools_enable_history = m_tools_history_menu->AppendCheckItem(wxID_ANY, _("Enable History"));
    m_tools_history_menu->AppendSeparator();

    m_tools_menu->AppendSubMenu(m_tools_history_menu, "History");

    // Browsing data menu
    wxMenu* browsingDataMenu = new wxMenu();
    browsingDataMenu->Append(ID_CLEAR_BROWSING_DATA_ALL, _("All"));
    browsingDataMenu->Append(ID_CLEAR_BROWSING_DATA_CACHE, _("Cache"));
    browsingDataMenu->Append(ID_CLEAR_BROWSING_DATA_COOKIES, _("Cookies"));
    browsingDataMenu->Append(ID_CLEAR_BROWSING_DATA_DOM_STORAGE, _("DOM Storage"));
    browsingDataMenu->Append(ID_CLEAR_BROWSING_DATA_OTHER, _("Other"));
    browsingDataMenu->AppendSeparator();
    browsingDataMenu->Append(ID_CLEAR_BROWSING_DATA_LAST_HOUR, _("All in last hour"));
    m_tools_menu->AppendSubMenu(browsingDataMenu, _("Clear Browsing Data"));

    //Create an editing menu
    wxMenu* editmenu = new wxMenu();
    m_edit_cut = editmenu->Append(wxID_ANY, _("Cut"));
    m_edit_copy = editmenu->Append(wxID_ANY, _("Copy"));
    m_edit_paste = editmenu->Append(wxID_ANY, _("Paste"));
    editmenu->AppendSeparator();
    m_edit_undo = editmenu->Append(wxID_ANY, _("Undo"));
    m_edit_redo = editmenu->Append(wxID_ANY, _("Redo"));
    editmenu->AppendSeparator();
    m_edit_mode = editmenu->AppendCheckItem(wxID_ANY, _("Edit Mode"));

    m_tools_menu->AppendSeparator();
    m_tools_menu->AppendSubMenu(editmenu, "Edit");

    wxMenu* scroll_menu = new wxMenu;
    m_scroll_line_up = scroll_menu->Append(wxID_ANY, "Line &up");
    m_scroll_line_down = scroll_menu->Append(wxID_ANY, "Line &down");
    m_scroll_page_up = scroll_menu->Append(wxID_ANY, "Page u&p");
    m_scroll_page_down = scroll_menu->Append(wxID_ANY, "Page d&own");
    m_tools_menu->AppendSubMenu(scroll_menu, "Scroll");

    wxMenu* script_menu = new wxMenu;
    m_script_string = script_menu->Append(wxID_ANY, "Return String");
    m_script_integer = script_menu->Append(wxID_ANY, "Return integer");
    m_script_double = script_menu->Append(wxID_ANY, "Return double");
    m_script_bool = script_menu->Append(wxID_ANY, "Return bool");
    m_script_object = script_menu->Append(wxID_ANY, "Return JSON object");
    m_script_array = script_menu->Append(wxID_ANY, "Return array");
    m_script_dom = script_menu->Append(wxID_ANY, "Modify DOM");
    m_script_undefined = script_menu->Append(wxID_ANY, "Return undefined");
    m_script_null = script_menu->Append(wxID_ANY, "Return null");
    m_script_date = script_menu->Append(wxID_ANY, "Return Date");
#if wxUSE_WEBVIEW_IE
    if (!wxWebView::IsBackendAvailable(wxWebViewBackendEdge))
    {
        m_script_object_el = script_menu->Append(wxID_ANY, "Return JSON object changing emulation level");
        m_script_date_el = script_menu->Append(wxID_ANY, "Return Date changing emulation level");
        m_script_array_el = script_menu->Append(wxID_ANY, "Return array changing emulation level");
    }
#endif
    m_script_async = script_menu->Append(wxID_ANY, "Return String async");
    m_script_message = script_menu->Append(wxID_ANY, "Send script message");
    m_script_custom = script_menu->Append(wxID_ANY, "Custom script");
    m_tools_menu->AppendSubMenu(script_menu, _("Run Script"));
    wxMenuItem* addUserScript = m_tools_menu->Append(wxID_ANY, _("Add user script"));
    wxMenuItem* setCustomUserAgent = m_tools_menu->Append(wxID_ANY, _("Set custom user agent"));
    wxMenuItem* setProxy = m_tools_menu->Append(wxID_ANY, _("Set proxy"));

    //Selection menu
    wxMenu* selection = new wxMenu();
    m_selection_clear = selection->Append(wxID_ANY, _("Clear Selection"));
    m_selection_delete = selection->Append(wxID_ANY, _("Delete Selection"));
    wxMenuItem* selectall = selection->Append(wxID_ANY, _("Select All"));

    editmenu->AppendSubMenu(selection, "Selection");

    wxMenu* handlers = new wxMenu();
    wxMenuItem* loadscheme =  handlers->Append(wxID_ANY, _("Custom Scheme"));
    wxMenuItem* usememoryfs =  handlers->Append(wxID_ANY, _("Memory File System"));
    wxMenuItem* advancedHandler =  handlers->Append(wxID_ANY, _("Advanced Handler"));
    m_tools_menu->AppendSubMenu(handlers, _("Handler Examples"));

    m_context_menu = m_tools_menu->AppendCheckItem(wxID_ANY, _("Enable Context Menu"));
    m_browser_accelerator_keys = m_tools_menu->AppendCheckItem(wxID_ANY, _("Enable Browser Accelerator Keys"));
    m_dev_tools = m_tools_menu->AppendCheckItem(wxID_ANY, _("Enable Dev Tools"));
    auto* const show_dev_tools = m_tools_menu->Append(wxID_ANY, _("Show Dev Tools"));

    if (m_flags & Main)
    {
        wxMenuItem* showLog = m_tools_menu->AppendCheckItem(wxID_ANY, _("Show Log"));
        showLog->Check();
        Bind(wxEVT_MENU, [this](wxCommandEvent& evt) {
            m_log_textCtrl->Show(evt.IsChecked());
            Layout();
        }, showLog->GetId());
    }

    //By default we want to handle navigation and new windows
    m_tools_handle_navigation->Check();
    m_tools_handle_new_window->Check();
    m_tools_enable_history->Check();

    //Zoom
    m_zoomFactor = 100;
    m_tools_medium->Check();

    if(!m_browser->CanSetZoomType(wxWEBVIEW_ZOOM_TYPE_LAYOUT))
        m_tools_layout->Enable(false);

    // Connect the toolbar events
    Bind(wxEVT_TOOL, &WebFrame::OnBack, this, m_toolbar_back->GetId());
    Bind(wxEVT_TOOL, &WebFrame::OnForward, this, m_toolbar_forward->GetId());
    Bind(wxEVT_TOOL, &WebFrame::OnStop, this, m_toolbar_stop->GetId());
    Bind(wxEVT_TOOL, &WebFrame::OnReload, this, m_toolbar_reload->GetId());
    Bind(wxEVT_TOOL, &WebFrame::OnToolsClicked, this, m_toolbar_tools->GetId());

    Bind(wxEVT_TEXT_ENTER, &WebFrame::OnUrl, this, m_url->GetId());

    // Connect find toolbar events.
    Bind(wxEVT_TOOL, &WebFrame::OnFindDone, this, m_find_toolbar_done->GetId());
    Bind(wxEVT_TOOL, &WebFrame::OnFindText, this, m_find_toolbar_next->GetId());
    Bind(wxEVT_TOOL, &WebFrame::OnFindText, this, m_find_toolbar_previous->GetId());

    // Connect find control events.
    Bind(wxEVT_TEXT, &WebFrame::OnFindText, this, m_find_ctrl->GetId());
    Bind(wxEVT_TEXT_ENTER, &WebFrame::OnFindText, this, m_find_ctrl->GetId());

    // Connect the webview events
    Bind(wxEVT_WEBVIEW_NAVIGATING, &WebFrame::OnNavigationRequest, this, m_browser->GetId());
    Bind(wxEVT_WEBVIEW_NAVIGATED, &WebFrame::OnNavigationComplete, this, m_browser->GetId());
    Bind(wxEVT_WEBVIEW_LOADED, &WebFrame::OnDocumentLoaded, this, m_browser->GetId());
    Bind(wxEVT_WEBVIEW_ERROR, &WebFrame::OnError, this, m_browser->GetId());
    Bind(wxEVT_WEBVIEW_NEWWINDOW, &WebFrame::OnNewWindow, this, m_browser->GetId());
    Bind(wxEVT_WEBVIEW_NEWWINDOW_FEATURES, &WebFrame::OnNewWindowFeatures, this, m_browser->GetId());
    Bind(wxEVT_WEBVIEW_TITLE_CHANGED, &WebFrame::OnTitleChanged, this, m_browser->GetId());
    Bind(wxEVT_WEBVIEW_FULLSCREEN_CHANGED, &WebFrame::OnFullScreenChanged, this, m_browser->GetId());
    Bind(wxEVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED, &WebFrame::OnScriptMessage, this, m_browser->GetId());
    Bind(wxEVT_WEBVIEW_SCRIPT_RESULT, &WebFrame::OnScriptResult, this, m_browser->GetId());
    Bind(wxEVT_WEBVIEW_WINDOW_CLOSE_REQUESTED, &WebFrame::OnWindowCloseRequested, this, m_browser->GetId());

    // Connect the menu events
    Bind(wxEVT_MENU, &WebFrame::OnSetPage, this, setPage->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnViewSourceRequest, this, viewSource->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnViewTextRequest, this, viewText->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnPrint, this, print->GetId());
#if wxUSE_PRINTING_ARCHITECTURE
    Bind(wxEVT_MENU, &WebFrame::OnPrintWithSettings, this, printWithSettings->GetId());
#endif
    Bind(wxEVT_MENU, &WebFrame::OnPrintToPDF, this, printToPDF->GetId());
#if wxUSE_PRINTING_ARCHITECTURE && (defined(__WXMSW__) || defined(__WXGTK__))
    Bind(wxEVT_MENU, &WebFrame::OnPrintToPDFWithSettings, this, printToPDFWithSettings->GetId());
#endif
    Bind(wxEVT_MENU, &WebFrame::OnOpenPrivateWindow, this, openPrivate->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnZoomLayout, this, m_tools_layout->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnSetZoom, this, m_tools_tiny->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnSetZoom, this, m_tools_small->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnSetZoom, this, m_tools_medium->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnSetZoom, this, m_tools_large->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnSetZoom, this, m_tools_largest->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnSetZoom, this, m_tools_custom->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnClearHistory, this, clearhist->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnEnableHistory, this, m_tools_enable_history->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnCut, this, m_edit_cut->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnCopy, this, m_edit_copy->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnPaste, this, m_edit_paste->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnUndo, this, m_edit_undo->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnRedo, this, m_edit_redo->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnMode, this, m_edit_mode->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnScrollLineUp, this, m_scroll_line_up->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnScrollLineDown, this, m_scroll_line_down->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnScrollPageUp, this, m_scroll_page_up->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnScrollPageDown, this, m_scroll_page_down->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnRunScriptString, this, m_script_string->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnRunScriptInteger, this, m_script_integer->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnRunScriptDouble, this, m_script_double->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnRunScriptBool, this, m_script_bool->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnRunScriptObject, this, m_script_object->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnRunScriptArray, this, m_script_array->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnRunScriptDOM, this, m_script_dom->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnRunScriptUndefined, this, m_script_undefined->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnRunScriptNull, this, m_script_null->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnRunScriptDate, this, m_script_date->GetId());
#if wxUSE_WEBVIEW_IE
    if (!wxWebView::IsBackendAvailable(wxWebViewBackendEdge))
    {
        Bind(wxEVT_MENU, &WebFrame::OnRunScriptObjectWithEmulationLevel, this, m_script_object_el->GetId());
        Bind(wxEVT_MENU, &WebFrame::OnRunScriptDateWithEmulationLevel, this, m_script_date_el->GetId());
        Bind(wxEVT_MENU, &WebFrame::OnRunScriptArrayWithEmulationLevel, this, m_script_array_el->GetId());
    }
#endif
    Bind(wxEVT_MENU, &WebFrame::OnRunScriptMessage, this, m_script_message->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnRunScriptCustom, this, m_script_custom->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnRunScriptAsync, this, m_script_async->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnAddUserScript, this, addUserScript->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnSetCustomUserAgent, this, setCustomUserAgent->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnSetProxy, this, setProxy->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnClearBrowsingData, this, ID_CLEAR_BROWSING_DATA_ALL, ID_CLEAR_BROWSING_DATA_LAST_HOUR);
    Bind(wxEVT_MENU, &WebFrame::OnClearSelection, this, m_selection_clear->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnDeleteSelection, this, m_selection_delete->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnSelectAll, this, selectall->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnLoadScheme, this, loadscheme->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnUseMemoryFS, this, usememoryfs->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnLoadAdvancedHandler, this, advancedHandler->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnFind, this, m_find->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnEnableContextMenu, this, m_context_menu->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnEnableDevTools, this, m_dev_tools->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnShowDevTools, this, show_dev_tools->GetId());
    Bind(wxEVT_MENU, &WebFrame::OnEnableBrowserAcceleratorKeys, this, m_browser_accelerator_keys->GetId());

    //Connect the idle events
    Bind(wxEVT_IDLE, &WebFrame::OnIdle, this);
}

WebFrame::~WebFrame()
{
    delete m_tools_menu;
}

/**
  * Method that retrieves the current state from the web control and updates the GUI
  * the reflect this current state.
  */
void WebFrame::UpdateState()
{
    m_toolbar->EnableTool( m_toolbar_back->GetId(), m_browser->CanGoBack() );
    m_toolbar->EnableTool( m_toolbar_forward->GetId(), m_browser->CanGoForward() );

    if (m_browser->IsBusy())
    {
        m_toolbar->EnableTool( m_toolbar_stop->GetId(), true );
    }
    else
    {
        m_toolbar->EnableTool( m_toolbar_stop->GetId(), false );
    }

    SetTitle(GetPrivatePrefix() + m_browser->GetCurrentTitle());

    m_url->SetValue( m_browser->GetCurrentURL() );
}

void WebFrame::OnIdle(wxIdleEvent& WXUNUSED(evt))
{
    if(m_browser->IsBusy())
    {
        wxSetCursor(wxCURSOR_ARROWWAIT);
        m_toolbar->EnableTool(m_toolbar_stop->GetId(), true);
    }
    else
    {
        wxSetCursor(wxNullCursor);
        m_toolbar->EnableTool(m_toolbar_stop->GetId(), false);
    }
}

/**
  * Callback invoked when user entered an URL and pressed enter
  */
void WebFrame::OnUrl(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->LoadURL( m_url->GetValue() );
    m_browser->SetFocus();
    UpdateState();
}

/**
    * Callback invoked when user pressed the "back" button
    */
void WebFrame::OnBack(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->GoBack();
    UpdateState();
}

/**
  * Callback invoked when user pressed the "forward" button
  */
void WebFrame::OnForward(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->GoForward();
    UpdateState();
}

/**
  * Callback invoked when user pressed the "stop" button
  */
void WebFrame::OnStop(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->Stop();
    UpdateState();
}

/**
  * Callback invoked when user pressed the "reload" button
  */
void WebFrame::OnReload(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->Reload();
    UpdateState();
}

void WebFrame::OnClearHistory(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->ClearHistory();
    UpdateState();
}

void WebFrame::OnEnableHistory(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->EnableHistory(m_tools_enable_history->IsChecked());
    UpdateState();
}

void WebFrame::OnCut(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->Cut();
}

void WebFrame::OnCopy(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->Copy();
}

void WebFrame::OnPaste(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->Paste();
}

void WebFrame::OnUndo(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->Undo();
}

void WebFrame::OnRedo(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->Redo();
}

void WebFrame::OnMode(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->SetEditable(m_edit_mode->IsChecked());
}

void WebFrame::OnLoadScheme(wxCommandEvent& WXUNUSED(evt))
{
    wxPathList pathlist;
    pathlist.Add(".");
    pathlist.Add("..");
    pathlist.Add("../help");
    pathlist.Add("../../../samples/help");

    wxString path = wxFileName(pathlist.FindValidPath("doc.zip")).GetAbsolutePath();
    //Under MSW we need to flip the slashes
    path.Replace("\\", "/");
    path = "wxfs:///" + path + ";protocol=zip/doc.htm";
    m_browser->LoadURL(path);
}

void WebFrame::OnUseMemoryFS(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->LoadURL("memory:page1.htm");
}

void WebFrame::OnLoadAdvancedHandler(wxCommandEvent& WXUNUSED(evt))
{
    wxPathList pathlist;
    pathlist.Add(".");
    pathlist.Add("..");

    wxString path = wxFileName(pathlist.FindValidPath("handler_advanced.html")).GetAbsolutePath();
    path = "file://" + path;
    m_browser->LoadURL(path);
}

void WebFrame::OnEnableContextMenu(wxCommandEvent& evt)
{
    m_browser->EnableContextMenu(evt.IsChecked());
}

void WebFrame::OnEnableDevTools(wxCommandEvent& evt)
{
    m_browser->EnableAccessToDevTools(evt.IsChecked());
}

void WebFrame::OnShowDevTools(wxCommandEvent& WXUNUSED(evt))
{
    if ( !m_browser->ShowDevTools() )
        wxLogWarning("Failed to show development tools window");
}

void WebFrame::OnEnableBrowserAcceleratorKeys(wxCommandEvent& evt)
{
    m_browser->EnableBrowserAcceleratorKeys(evt.IsChecked());
}

void WebFrame::OnFind(wxCommandEvent& WXUNUSED(evt))
{
    wxString value = m_browser->GetSelectedText();
    if(value.Len() > 150)
    {
        value.Truncate(150);
    }
    m_find_ctrl->SetValue(value);
    if(!m_find_toolbar->IsShown()){
        m_find_toolbar->Show(true);
        SendSizeEvent();
    }
    m_find_ctrl->SelectAll();
}

void WebFrame::OnFindDone(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->Find("");
    m_find_toolbar->Show(false);
    SendSizeEvent();
}

void WebFrame::OnFindText(wxCommandEvent& evt)
{
    int flags = 0;

    if(m_find_toolbar_wrap->IsChecked())
        flags |= wxWEBVIEW_FIND_WRAP;
    if(m_find_toolbar_wholeword->IsChecked())
        flags |= wxWEBVIEW_FIND_ENTIRE_WORD;
    if(m_find_toolbar_matchcase->IsChecked())
        flags |= wxWEBVIEW_FIND_MATCH_CASE;
    if(m_find_toolbar_highlight->IsChecked())
        flags |= wxWEBVIEW_FIND_HIGHLIGHT_RESULT;

    if(m_find_toolbar_previous->GetId() == evt.GetId())
        flags |= wxWEBVIEW_FIND_BACKWARDS;

    wxString find_text = m_find_ctrl->GetValue();
    long count = m_browser->Find(find_text, flags);

    if(m_findText != find_text)
    {
        m_findCount = count;
        m_findText = find_text;
    }

    if(count != wxNOT_FOUND || find_text.IsEmpty())
    {
        m_find_ctrl->SetBackgroundColour(*wxWHITE);
    }
    else
    {
        m_find_ctrl->SetBackgroundColour(wxColour(255, 101, 101));
    }

    m_find_ctrl->Refresh();

    //Log the result, note that count is zero indexed.
    if(count != m_findCount)
    {
        count++;
    }
    wxLogMessage("Searching for:%s  current match:%li/%i", m_findText, count, m_findCount);
}

/**
  * Callback invoked when there is a request to load a new page (for instance
  * when the user clicks a link)
  */
void WebFrame::OnNavigationRequest(wxWebViewEvent& evt)
{
    if(m_info->IsShown())
    {
        m_info->Dismiss();
    }

    wxLogMessage("Navigation request to '%s' (target='%s')%s",
                 evt.GetURL(),
                 evt.GetTarget(),
                 evt.IsTargetMainFrame() ? " mainFrame" : "");

    //If we don't want to handle navigation then veto the event and navigation
    //will not take place, we also need to stop the loading animation
    if(!m_tools_handle_navigation->IsChecked())
    {
        evt.Veto();
        m_toolbar->EnableTool( m_toolbar_stop->GetId(), false );
    }
    else
    {
        UpdateState();
    }
}

/**
  * Callback invoked when a navigation request was accepted
  */
void WebFrame::OnNavigationComplete(wxWebViewEvent& evt)
{
    wxLogMessage("Navigation complete; url='%s'", evt.GetURL());
    UpdateState();
}

/**
  * Callback invoked when a page is finished loading
  */
void WebFrame::OnDocumentLoaded(wxWebViewEvent& evt)
{
    //Only notify if the document is the main frame, not a subframe
    if(evt.GetURL() == m_browser->GetCurrentURL())
    {
        wxLogMessage("Document loaded; url='%s'", evt.GetURL());
    }
    UpdateState();
}

/**
  * On new window, we veto to stop extra windows appearing
  */
void WebFrame::OnNewWindow(wxWebViewEvent& evt)
{
    wxString flag = " (other)";

    if(evt.GetNavigationAction() == wxWEBVIEW_NAV_ACTION_USER)
    {
        flag = " (user)";
    }

    wxLogMessage("New window; url='%s'%s", evt.GetURL(), flag);

    //If we handle new window events then create a new frame
    if (!m_tools_handle_new_window->IsChecked())
        evt.Veto();

    UpdateState();
}

void WebFrame::OnNewWindowFeatures(wxWebViewEvent &evt)
{
    wxWebViewWindowFeatures* features = evt.GetTargetWindowFeatures();
    if (!features)
        return;

    wxString featureDescription;
    if (features->GetPosition().IsFullySpecified())
        featureDescription += wxString::Format(" Position: %d, %d; ", features->GetPosition().x, features->GetPosition().y);
    if (features->GetSize().IsFullySpecified())
        featureDescription += wxString::Format(" Size: %d, %d; ", features->GetSize().x, features->GetSize().y);
    if (features->ShouldDisplayMenuBar())
        featureDescription += " MenuBar; ";
    if (features->ShouldDisplayStatusBar())
        featureDescription += " StatusBar; ";
    if (features->ShouldDisplayToolBar())
        featureDescription += " ToolBar; ";
    if (features->ShouldDisplayScrollBars())
        featureDescription += " ScrollBars; ";

    wxLogMessage("Window features of child webview are available." + featureDescription);

    // Create child frame with the features specified by window.open() call
    WebFrame* newFrame = new WebFrame(evt.GetURL(), WebFrame::Child, features);
    newFrame->Show();
}

void WebFrame::OnTitleChanged(wxWebViewEvent& evt)
{
    SetTitle(GetPrivatePrefix() + evt.GetString());
    wxLogMessage("Title changed; title='%s'", evt.GetString());
}

void WebFrame::OnFullScreenChanged(wxWebViewEvent & evt)
{
    wxLogMessage("Full screen changed; status = %d", evt.GetInt());
    ShowFullScreen(evt.GetInt() != 0);
}

void WebFrame::OnScriptMessage(wxWebViewEvent& evt)
{
    wxLogMessage("Script message received; value = %s, handler = %s", evt.GetString(), evt.GetMessageHandler());
}

void WebFrame::OnScriptResult(wxWebViewEvent& evt)
{
    if (evt.IsError())
        wxLogError("Async script execution failed: %s", evt.GetString());
    else
        wxLogMessage("Async script result received; value = %s", evt.GetString());
}

void WebFrame::OnWindowCloseRequested(wxWebViewEvent& WXUNUSED(evt))
{
    wxLogMessage("Window close requested");
    if (!(m_flags & Main))
        Close();
}

void WebFrame::OnSetPage(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->SetPage
               (
                "<html><title>New Page</title>"
                "<body>Created using <tt>SetPage()</tt> method.</body></html>",
                wxString()
               );
}

/**
  * Invoked when user selects the "View Source" menu item
  */
void WebFrame::OnViewSourceRequest(wxCommandEvent& WXUNUSED(evt))
{
    SourceViewDialog dlg(this, m_browser->GetPageSource());
    dlg.ShowModal();
}

/**
 * Invoked when user selects the "View Text" menu item
 */
void WebFrame::OnViewTextRequest(wxCommandEvent& WXUNUSED(evt))
{
    wxDialog textViewDialog(this, wxID_ANY, "Page Text",
                            wxDefaultPosition, wxSize(700,500),
                            wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER);
#if wxUSE_STC
    wxStyledTextCtrl* text = new wxStyledTextCtrl(&textViewDialog, wxID_ANY);
    text->SetText(m_browser->GetPageText());
#else // !wxUSE_STC
    wxTextCtrl* text = new wxTextCtrl(this, wxID_ANY, m_browser->GetPageText(),
                                      wxDefaultPosition, wxDefaultSize,
                                      wxTE_MULTILINE |
                                      wxTE_RICH |
                                      wxTE_READONLY);
#endif // wxUSE_STC/!wxUSE_STC
    wxBoxSizer* sizer = new wxBoxSizer(wxVERTICAL);
    sizer->Add(text, 1, wxEXPAND);
    textViewDialog.SetSizer(sizer);
    textViewDialog.ShowModal();
}

/**
  * Invoked when user selects the "Menu" item
  */
void WebFrame::OnToolsClicked(wxCommandEvent& WXUNUSED(evt))
{
    if(m_browser->GetCurrentURL() == "")
        return;

    m_edit_cut->Enable(m_browser->CanCut());
    m_edit_copy->Enable(m_browser->CanCopy());
    m_edit_paste->Enable(m_browser->CanPaste());

    m_edit_undo->Enable(m_browser->CanUndo());
    m_edit_redo->Enable(m_browser->CanRedo());

    m_selection_clear->Enable(m_browser->HasSelection());
    m_selection_delete->Enable(m_browser->HasSelection());

    m_context_menu->Check(m_browser->IsContextMenuEnabled());
    m_dev_tools->Check(m_browser->IsAccessToDevToolsEnabled());
    m_browser_accelerator_keys->Check(m_browser->AreBrowserAcceleratorKeysEnabled());

    //Firstly we clear the existing menu items, then we add the current ones
    for ( auto& item : m_histMenuItems )
    {
        m_tools_history_menu->Destroy(item.first);
    }
    m_histMenuItems.clear();

    // We can't use empty labels for the menu items, so use this helper to give
    // them at least some name if we don't have anything better.
    const auto makeLabel = [](const wxString& title)
    {
        return title.empty() ? wxString("(untitled)") : title;
    };

    wxMenuItem* item;

    for ( const auto& histItem : m_browser->GetBackwardHistory() )
    {
        item = m_tools_history_menu->AppendRadioItem(wxID_ANY, makeLabel(histItem->GetTitle()));
        m_histMenuItems[item->GetId()] = histItem;
        Bind(wxEVT_MENU, &WebFrame::OnHistory, this, item->GetId());
    }

    item = m_tools_history_menu->AppendRadioItem(wxID_ANY, makeLabel(m_browser->GetCurrentTitle()));
    item->Check();

    //No need to connect the current item
    m_histMenuItems[item->GetId()] = wxSharedPtr<wxWebViewHistoryItem>(new wxWebViewHistoryItem(m_browser->GetCurrentURL(), m_browser->GetCurrentTitle()));

    for ( const auto& histItem : m_browser->GetForwardHistory() )
    {
        item = m_tools_history_menu->AppendRadioItem(wxID_ANY, makeLabel(histItem->GetTitle()));
        m_histMenuItems[item->GetId()] = histItem;
        Bind(wxEVT_TOOL, &WebFrame::OnHistory, this, item->GetId());
    }

    wxPoint position = ScreenToClient( wxGetMousePosition() );
    PopupMenu(m_tools_menu, position.x, position.y);
}

/**
  * Invoked when user selects the zoom size in the menu
  */
void WebFrame::OnSetZoom(wxCommandEvent& evt)
{
    if (evt.GetId() == m_tools_tiny->GetId())
    {
        m_browser->SetZoom(wxWEBVIEW_ZOOM_TINY);
    }
    else if (evt.GetId() == m_tools_small->GetId())
    {
        m_browser->SetZoom(wxWEBVIEW_ZOOM_SMALL);
    }
    else if (evt.GetId() == m_tools_medium->GetId())
    {
        m_browser->SetZoom(wxWEBVIEW_ZOOM_MEDIUM);
    }
    else if (evt.GetId() == m_tools_large->GetId())
    {
        m_browser->SetZoom(wxWEBVIEW_ZOOM_LARGE);
    }
    else if (evt.GetId() == m_tools_largest->GetId())
    {
        m_browser->SetZoom(wxWEBVIEW_ZOOM_LARGEST);
    }
    else if (evt.GetId() == m_tools_custom->GetId())
    {
        m_zoomFactor = m_browser->GetZoomFactor() * 100;
        OnZoomCustom(evt);
    }
    else
    {
        wxFAIL;
    }
}

void WebFrame::OnZoomLayout(wxCommandEvent& WXUNUSED(evt))
{
    if(m_tools_layout->IsChecked())
        m_browser->SetZoomType(wxWEBVIEW_ZOOM_TYPE_LAYOUT);
    else
        m_browser->SetZoomType(wxWEBVIEW_ZOOM_TYPE_TEXT);
}

void WebFrame::OnZoomCustom(wxCommandEvent& WXUNUSED(evt))
{
    wxNumberEntryDialog dialog
                      (
                        this,
                        "Enter zoom factor as a percentage (10-10000)%",
                        "Zoom Factor:",
                        "Change Zoom Factor",
                        m_zoomFactor,
                        10, 10000
                      );
    if( dialog.ShowModal() != wxID_OK )
        return;

    m_zoomFactor = dialog.GetValue();
    m_browser->SetZoomFactor((float)m_zoomFactor/100);
}

void WebFrame::OnHistory(wxCommandEvent& evt)
{
    m_browser->LoadHistoryItem(m_histMenuItems[evt.GetId()]);
}

void WebFrame::RunScript(const wxString& javascript)
{
    // Remember the script we run in any case, so the next time the user opens
    // the "Run Script" dialog box, it is shown there for convenient updating.
    m_javascript = javascript;

    wxLogMessage("Running JavaScript:\n%s\n", javascript);

    wxString result;
    if ( m_browser->RunScript(javascript, &result) )
    {
        wxLogMessage("RunScript() returned \"%s\"", result);
    }
    else
    {
        wxLogWarning("RunScript() failed");
    }
}

void WebFrame::OnRunScriptString(wxCommandEvent& WXUNUSED(evt))
{
    RunScript("function f(a){return a;}f('Hello World!');");
}

void WebFrame::OnRunScriptInteger(wxCommandEvent& WXUNUSED(evt))
{
    RunScript("function f(a){return a;}f(123);");
}

void WebFrame::OnRunScriptDouble(wxCommandEvent& WXUNUSED(evt))
{
    RunScript("function f(a){return a;}f(2.34);");
}

void WebFrame::OnRunScriptBool(wxCommandEvent& WXUNUSED(evt))
{
    RunScript("function f(a){return a;}f(false);");
}

void WebFrame::OnRunScriptObject(wxCommandEvent& WXUNUSED(evt))
{
    RunScript("function f(){var person = new Object();person.name = 'Foo'; \
        person.lastName = 'Bar';return person;}f();");
}

void WebFrame::OnRunScriptArray(wxCommandEvent& WXUNUSED(evt))
{
    RunScript("function f(){ return [\"foo\", \"bar\"]; }f();");
}

void WebFrame::OnRunScriptDOM(wxCommandEvent& WXUNUSED(evt))
{
    RunScript("document.write(\"Hello World!\");");
}

void WebFrame::OnRunScriptUndefined(wxCommandEvent& WXUNUSED(evt))
{
    RunScript("function f(){var person = new Object();}f();");
}

void WebFrame::OnRunScriptNull(wxCommandEvent& WXUNUSED(evt))
{
    RunScript("function f(){return null;}f();");
}

void WebFrame::OnRunScriptDate(wxCommandEvent& WXUNUSED(evt))
{
    RunScript("function f(){var d = new Date('10/08/2017 21:30:40'); \
        var tzoffset = d.getTimezoneOffset() * 60000; \
        return new Date(d.getTime() - tzoffset);}f();");
}

#if wxUSE_WEBVIEW_IE
void WebFrame::OnRunScriptObjectWithEmulationLevel(wxCommandEvent& WXUNUSED(evt))
{
    wxWebViewIE::MSWSetModernEmulationLevel();
    RunScript("function f(){var person = new Object();person.name = 'Foo'; \
        person.lastName = 'Bar';return person;}f();");
    wxWebViewIE::MSWSetModernEmulationLevel(false);
}

void WebFrame::OnRunScriptDateWithEmulationLevel(wxCommandEvent& WXUNUSED(evt))
{
    wxWebViewIE::MSWSetModernEmulationLevel();
    RunScript("function f(){var d = new Date('10/08/2017 21:30:40'); \
        var tzoffset = d.getTimezoneOffset() * 60000; return \
        new Date(d.getTime() - tzoffset);}f();");
    wxWebViewIE::MSWSetModernEmulationLevel(false);
}

void WebFrame::OnRunScriptArrayWithEmulationLevel(wxCommandEvent& WXUNUSED(evt))
{
    wxWebViewIE::MSWSetModernEmulationLevel();
    RunScript("function f(){ return [\"foo\", \"bar\"]; }f();");
    wxWebViewIE::MSWSetModernEmulationLevel(false);
}
#endif

void WebFrame::OnRunScriptMessage(wxCommandEvent& WXUNUSED(evt))
{
    RunScript("window.wx.postMessage('This is a web message');");
}

void WebFrame::OnRunScriptAsync(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->RunScriptAsync("function f(a){return a;}f('Hello World!');");
}

void WebFrame::OnRunScriptCustom(wxCommandEvent& WXUNUSED(evt))
{
    wxTextEntryDialog dialog
                      (
                        this,
                        "Please enter JavaScript code to execute",
                        wxGetTextFromUserPromptStr,
                        m_javascript,
                        wxOK | wxCANCEL | wxCENTRE | wxTE_MULTILINE
                      );
    if( dialog.ShowModal() != wxID_OK )
        return;

    RunScript(dialog.GetValue());
}

void WebFrame::OnAddUserScript(wxCommandEvent & WXUNUSED(evt))
{
    wxString userScript = "window.wx_test_var = 'wxWidgets webview sample';";
    wxTextEntryDialog dialog
    (
        this,
        "Enter the JavaScript code to run as the initialization script that runs before any script in the HTML document.",
        wxGetTextFromUserPromptStr,
        userScript,
        wxOK | wxCANCEL | wxCENTRE | wxTE_MULTILINE
    );
    if (dialog.ShowModal() != wxID_OK)
        return;

    if (!m_browser->AddUserScript(dialog.GetValue()))
        wxLogError("Could not add user script");
}

void WebFrame::OnSetCustomUserAgent(wxCommandEvent& WXUNUSED(evt))
{
    wxString customUserAgent = m_browser->GetUserAgent();
    wxTextEntryDialog dialog
    (
        this,
        "Enter the custom user agent string you would like to use.",
        wxGetTextFromUserPromptStr,
        customUserAgent,
        wxOK | wxCANCEL | wxCENTRE
    );
    if (dialog.ShowModal() != wxID_OK)
        return;

    if (!m_browser->SetUserAgent(customUserAgent))
        wxLogError("Could not set custom user agent");
}

void WebFrame::OnSetProxy(wxCommandEvent& WXUNUSED(evt))
{
    static wxString s_proxy;
    if ( s_proxy.empty() )
        wxGetEnv("http_proxy", &s_proxy);

    const auto proxy = wxGetTextFromUser
        (
            "Enter the proxy to use",
            wxGetTextFromUserPromptStr,
            s_proxy,
            this
        );

    if (proxy.empty())
        return;

    s_proxy = proxy;

    if (!m_browser->SetProxy(s_proxy))
        wxLogError("Could not set proxy");
}

void WebFrame::OnClearBrowsingData(wxCommandEvent &evt)
{
    int dataTypes;
    wxDateTime since((time_t) 0);
    switch (evt.GetId())
    {
        case ID_CLEAR_BROWSING_DATA_ALL:
            dataTypes = wxWEBVIEW_BROWSING_DATA_ALL;
            break;
        case ID_CLEAR_BROWSING_DATA_CACHE:
            dataTypes = wxWEBVIEW_BROWSING_DATA_CACHE;
            break;
        case ID_CLEAR_BROWSING_DATA_COOKIES:
            dataTypes = wxWEBVIEW_BROWSING_DATA_COOKIES;
            break;
        case ID_CLEAR_BROWSING_DATA_DOM_STORAGE:
            dataTypes = wxWEBVIEW_BROWSING_DATA_DOM_STORAGE;
            break;
        case ID_CLEAR_BROWSING_DATA_OTHER:
            dataTypes = wxWEBVIEW_BROWSING_DATA_OTHER;
            break;
        case ID_CLEAR_BROWSING_DATA_LAST_HOUR:
            dataTypes = wxWEBVIEW_BROWSING_DATA_ALL;
            since = wxDateTime::Now() - wxTimeSpan::Hour();
            break;
        default:
            wxFAIL_MSG("Unexpected event ID");
            return;
    }

    if (!m_browser->ClearBrowsingData(dataTypes, since))
        wxLogError("Clearing this browsing data type is not supported by this backend");
}

void WebFrame::OnClearSelection(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->ClearSelection();
}

void WebFrame::OnDeleteSelection(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->DeleteSelection();
}

void WebFrame::OnSelectAll(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->SelectAll();
}

/**
  * Callback invoked when a loading error occurs
  */
void WebFrame::OnError(wxWebViewEvent& evt)
{
#define WX_ERROR_CASE(type) \
    case type: \
        category = #type; \
        break;

    wxString category;
    switch (evt.GetInt())
    {
        WX_ERROR_CASE(wxWEBVIEW_NAV_ERR_CONNECTION);
        WX_ERROR_CASE(wxWEBVIEW_NAV_ERR_CERTIFICATE);
        WX_ERROR_CASE(wxWEBVIEW_NAV_ERR_AUTH);
        WX_ERROR_CASE(wxWEBVIEW_NAV_ERR_SECURITY);
        WX_ERROR_CASE(wxWEBVIEW_NAV_ERR_NOT_FOUND);
        WX_ERROR_CASE(wxWEBVIEW_NAV_ERR_REQUEST);
        WX_ERROR_CASE(wxWEBVIEW_NAV_ERR_USER_CANCELLED);
        WX_ERROR_CASE(wxWEBVIEW_NAV_ERR_OTHER);
    }

    wxLogMessage("Error; url='%s', error='%s (%s)'",
                 evt.GetURL(), category, evt.GetString());

    //Show the info bar with an error
    m_info->ShowMessage(_("An error occurred loading ") + evt.GetURL() + "\n" +
    "'" + category + "'", wxICON_ERROR);

    UpdateState();
}

/**
  * Invoked when user selects "Print" from the menu
  */
void WebFrame::OnPrint(wxCommandEvent& WXUNUSED(evt))
{
    m_browser->Print();
}

#if wxUSE_PRINTING_ARCHITECTURE
void WebFrame::OnPrintWithSettings(wxCommandEvent& WXUNUSED(evt))
{
    // Let the user choose paper size and orientation
    wxArrayString paperChoices;
    paperChoices.Add("Letter (Portrait)");
    paperChoices.Add("Letter (Landscape)");
    paperChoices.Add("A4 (Portrait)");
    paperChoices.Add("A4 (Landscape)");
    paperChoices.Add("Legal (Portrait)");
    paperChoices.Add("Legal (Landscape)");

    int sel = wxGetSingleChoiceIndex(
        "Select paper size and orientation for printing:",
        "Print with Settings",
        paperChoices,
        this);

    if (sel == -1)
        return;

    wxPrintData printData;

    switch (sel)
    {
        case 0: printData.SetPaperId(wxPAPER_LETTER); printData.SetOrientation(wxPORTRAIT); break;
        case 1: printData.SetPaperId(wxPAPER_LETTER); printData.SetOrientation(wxLANDSCAPE); break;
        case 2: printData.SetPaperId(wxPAPER_A4);     printData.SetOrientation(wxPORTRAIT); break;
        case 3: printData.SetPaperId(wxPAPER_A4);     printData.SetOrientation(wxLANDSCAPE); break;
        case 4: printData.SetPaperId(wxPAPER_LEGAL);  printData.SetOrientation(wxPORTRAIT); break;
        case 5: printData.SetPaperId(wxPAPER_LEGAL);  printData.SetOrientation(wxLANDSCAPE); break;
    }

    wxLogMessage("Printing with paper=%s, orientation=%s",
        paperChoices[sel],
        printData.GetOrientation() == wxLANDSCAPE ? "Landscape" : "Portrait");

#ifdef __WXMSW__
    int printFlags = wxWEBVIEW_PRINT_DEFAULT;
    if (wxMessageBox("Hide header and footer?",
                     "Print with Settings",
                     wxYES_NO | wxICON_QUESTION, this) == wxYES)
    {
        printFlags |= wxWEBVIEW_PRINT_HIDE_HEADER_FOOTER;
    }

    m_browser->Print(printData, printFlags);
#else
    m_browser->Print(printData);
#endif
}
#endif // wxUSE_PRINTING_ARCHITECTURE

void WebFrame::OnPrintToPDF(wxCommandEvent& WXUNUSED(evt))
{
    wxFileDialog dlg(this, _("Save as PDF"), wxEmptyString, wxEmptyString,
                     _("PDF files (*.pdf)|*.pdf"),
                     wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
    if (dlg.ShowModal() != wxID_OK)
        return;

    if (!m_browser->PrintToPDF(dlg.GetPath()))
        wxLogError("PrintToPDF is not supported by this browser backend.");
}

#if wxUSE_PRINTING_ARCHITECTURE && (defined(__WXMSW__) || defined(__WXGTK__))

class WebFramePDFSettingsHook : public wxFileDialogCustomizeHook
{
public:
    void AddCustomControls(wxFileDialogCustomize& customizer) override
    {
        const wxString choices[] = {
            _("Letter (Portrait)"), _("Letter (Landscape)"),
            _("A4 (Portrait)"),     _("A4 (Landscape)"),
            _("Legal (Portrait)"),  _("Legal (Landscape)")
        };
        customizer.AddStaticText(_("Paper size:"));
        m_choice = customizer.AddChoice(WXSIZEOF(choices), choices);
        m_choice->SetSelection(m_sel);
    }

    void TransferDataFromCustomControls() override
    {
        m_sel = m_choice->GetSelection();
    }

    int GetSelection() const { return m_sel; }

private:
    wxFileDialogChoice* m_choice = nullptr;
    int m_sel = 2; // A4 Portrait
};

void WebFrame::OnPrintToPDFWithSettings(wxCommandEvent& WXUNUSED(evt))
{
    WebFramePDFSettingsHook hook;
    wxFileDialog dlg(this, _("Save as PDF"), wxEmptyString, wxEmptyString,
                     _("PDF files (*.pdf)|*.pdf"),
                     wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
    dlg.SetCustomizeHook(hook);
    if (dlg.ShowModal() != wxID_OK)
        return;

    wxPrintData printData;
    switch (hook.GetSelection())
    {
        case 0: printData.SetPaperId(wxPAPER_LETTER); printData.SetOrientation(wxPORTRAIT);  break;
        case 1: printData.SetPaperId(wxPAPER_LETTER); printData.SetOrientation(wxLANDSCAPE); break;
        case 2: printData.SetPaperId(wxPAPER_A4);     printData.SetOrientation(wxPORTRAIT);  break;
        case 3: printData.SetPaperId(wxPAPER_A4);     printData.SetOrientation(wxLANDSCAPE); break;
        case 4: printData.SetPaperId(wxPAPER_LEGAL);  printData.SetOrientation(wxPORTRAIT);  break;
        case 5: printData.SetPaperId(wxPAPER_LEGAL);  printData.SetOrientation(wxLANDSCAPE); break;
    }

    if (!m_browser->PrintToPDF(dlg.GetPath(), printData))
        wxLogError("PrintToPDF is not supported by this browser backend.");
}
#endif // wxUSE_PRINTING_ARCHITECTURE && (defined(__WXMSW__) || defined(__WXGTK__))

void WebFrame::OnOpenPrivateWindow(wxCommandEvent& WXUNUSED(evt))
{
    WebFrame* newFrame = new WebFrame(m_browser->GetCurrentURL(), WebFrame::Private);
    newFrame->Show();
}

SourceViewDialog::SourceViewDialog(wxWindow* parent, wxString source) :
                  wxDialog(parent, wxID_ANY, "Source Code",
                           wxDefaultPosition, wxSize(700,500),
                           wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
{
#if wxUSE_STC
    wxStyledTextCtrl* text = new wxStyledTextCtrl(this, wxID_ANY);
    text->SetMarginWidth(1, 30);
    text->SetMarginType(1, wxSTC_MARGIN_NUMBER);
    text->SetText(source);

    text->StyleClearAll();
    text->SetLexer(wxSTC_LEX_HTML);
    text->StyleSetForeground(wxSTC_H_DOUBLESTRING, wxColour(255,0,0));
    text->StyleSetForeground(wxSTC_H_SINGLESTRING, wxColour(255,0,0));
    text->StyleSetForeground(wxSTC_H_ENTITY, wxColour(255,0,0));
    text->StyleSetForeground(wxSTC_H_TAG, wxColour(0,150,0));
    text->StyleSetForeground(wxSTC_H_TAGUNKNOWN, wxColour(0,150,0));
    text->StyleSetForeground(wxSTC_H_ATTRIBUTE, wxColour(0,0,150));
    text->StyleSetForeground(wxSTC_H_ATTRIBUTEUNKNOWN, wxColour(0,0,150));
    text->StyleSetForeground(wxSTC_H_COMMENT, wxColour(150,150,150));
#else // !wxUSE_STC
    wxTextCtrl* text = new wxTextCtrl(this, wxID_ANY, source,
                                      wxDefaultPosition, wxDefaultSize,
                                      wxTE_MULTILINE |
                                      wxTE_RICH |
                                      wxTE_READONLY);
#endif // wxUSE_STC/!wxUSE_STC

    wxBoxSizer* sizer = new wxBoxSizer(wxVERTICAL);
    sizer->Add(text, 1, wxEXPAND);
    SetSizer(sizer);
}
