added desktop runtime

Author: johnpatek

example/CMakeLists.txt

@@ -22,9 +22,16 @@ configure_file(
     ${CMAKE_CURRENT_BINARY_DIR}/archive.hpp
     @ONLY
 )
-
-webframe_add_application(NAME example
-    SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp
-    INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}
-    LINK_LIBRARIES yyjson::yyjson hyperpage::hyperpage
-    RUNTIME server)
+if(WIN32)
+    webframe_add_application(NAME example
+        SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp
+        INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}
+        LINK_LIBRARIES yyjson::yyjson hyperpage::hyperpage
+        RUNTIME desktop server)
+else()
+    webframe_add_application(NAME example
+        SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp
+        INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}
+        LINK_LIBRARIES yyjson::yyjson hyperpage::hyperpage
+        RUNTIME server)
+endif()

include/webframe.hpp

@@ -32,10 +32,17 @@
 #include <webframe/handler.hpp>
 #include <webframe/router.hpp>
 
-#if defined(_WIN32) && defined(WEBFRAME_DESKTOP)
+#if defined(_WIN32) && defined(WEBFRAME_DESKTOP_RUNTIME)
 #define WEBFRAME_WIN32_APP 1
 #endif
 
+#if defined(WEBFRAME_WIN32_APP)
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#endif
+
 namespace webframe
 {
     enum class method
@@ -71,7 +78,7 @@ namespace webframe
     {
     public:
 #ifdef WEBFRAME_WIN32_APP
-        virtual int dispatch(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR pCmdLine, int nCmdShow, application *a, router *r) = 0;
+        virtual int dispatch(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow, application *a, router *r) = 0;
 #else
         virtual int dispatch(int argc, const char **argv, application *a, router *r) = 0;
 #endif
@@ -82,12 +89,12 @@ namespace webframe
 
 #if defined(WEBFRAME_WIN32_APP)
     #define WEBFRAME_MAIN(AppType) \
-        int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR pCmdLine, int nCmdShow) \
+        int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) \
         { \
             std::unique_ptr<webframe::runtime> runtime(webframe::webframe_init()); \
             AppType app; \
             webframe::router router; \
-            return runtime->dispatch(hInstance, hPrevInstance, pCmdLine, nCmdShow, &app, &router); \
+            return runtime->dispatch(hInstance, hPrevInstance, lpCmdLine, nCmdShow, &app, &router); \
         }
 #else
     #define WEBFRAME_MAIN(AppType) \

src/CMakeLists.txt

@@ -2,7 +2,15 @@ file(GLOB WEBFRAME_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
 set(WEBFRAME_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../include)
 
 if(BUILD_RUNTIME)
-    message(STATUS "Building desktop runtime")
+    if(WIN32)
+        file(GLOB WEBFRAME_DESKTOP_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/runtimes/desktop/*.cpp)
+        webframe_add_runtime(NAME desktop
+            SOURCES ${WEBFRAME_SOURCES} ${WEBFRAME_DESKTOP_SOURCES}
+            PUBLIC_INCLUDE_DIRS ${WEBFRAME_INCLUDE_DIR} 
+            PRIVATE_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/runtimes/desktop
+            PUBLIC_LINK_LIBRARIES wx::core wx::webview)
+        target_compile_definitions(webframe_desktop PUBLIC WEBFRAME_DESKTOP_RUNTIME=1)
+    endif()
     file(GLOB WEBFRAME_SERVER_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/runtimes/server/*.cpp)
     webframe_add_runtime(NAME server
         SOURCES ${WEBFRAME_SOURCES} ${WEBFRAME_SERVER_SOURCES}

src/runtimes/desktop/desktop.hpp

@@ -0,0 +1,66 @@
+#ifndef WEBFRAME_DESKTOP_HPP
+#define WEBFRAME_DESKTOP_HPP
+
+#include <webframe.hpp>
+
+#include <wx/wx.h>
+#include <wx/webview.h>
+#include <wx/uri.h>
+
+class wfApp;
+
+namespace webframe::desktop
+{
+    class request : public webframe::request
+    {
+    public:
+        request(const wxWebViewHandlerRequest *request);
+        ~request() = default;
+        webframe::method get_method() const override;
+        std::string get_path() const override;
+        bool get_header(const std::string &key, std::string &value) const override;
+        std::pair<const uint8_t *, size_t> get_body() const override;
+        void read_body(const std::function<void(const uint8_t *, size_t)> &callback) const override;
+    private:
+        const wxWebViewHandlerRequest *_request;
+        wxString _body;
+    };
+
+    class response : public webframe::response
+    {
+    public:
+        response(wxWebViewHandlerResponse *response, bool &sent);
+        ~response() = default;
+        void set_status(int status) override;
+        void set_header(const std::string &key, const std::string &value) override;
+        void set_body(const uint8_t *data, size_t size) override;
+        void write_body(const std::function<bool(std::pair<const uint8_t *, size_t> &)> &callback) override;
+    private:
+        wxWebViewHandlerResponse *_response;
+        bool &_sent;
+    };
+
+    class webview_handler : public wxWebViewHandler
+    {
+    public:
+        webview_handler(webframe::router *router);
+        ~webview_handler() = default;
+        void StartRequest(const wxWebViewHandlerRequest& request, wxSharedPtr<wxWebViewHandlerResponse> response) override;
+    private:
+        webframe::router *_router;
+    };
+
+    class runtime : public webframe::runtime
+    {
+    public:
+#ifdef WEBFRAME_WIN32_APP
+        int dispatch(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow, webframe::application *a, webframe::router *r) override;
+#else
+        int dispatch(int argc, const char **argv, webframe::application *a, webframe::router *r) override;
+#endif
+    private:
+        int launch_wx_app(wfApp *app, webframe::application *a, webframe::router *r);
+    };
+}
+
+#endif

src/runtimes/desktop/request.cpp

@@ -0,0 +1,75 @@
+#include <desktop.hpp>
+
+namespace webframe
+{
+    namespace desktop
+    {
+        request::request(const wxWebViewHandlerRequest *request) : _request(request)
+        {
+            _body = _request->GetDataString();
+        }
+
+        webframe::method request::get_method() const
+        {
+            const wxString method = _request->GetMethod();
+            webframe::method result;
+            if (method == "GET")
+            {
+                result = webframe::method::http_get;
+            }
+            else if (method == "POST")
+            {
+                result = webframe::method::http_post;
+            }
+            else if (method == "PUT")
+            {
+                result = webframe::method::http_put;
+            }
+            else if (method == "DELETE")
+            {
+                result = webframe::method::http_delete;
+            }
+            else
+            {
+                result = static_cast<webframe::method>(-1);
+            }
+            return result;
+        }
+
+        std::string request::get_path() const
+        {   
+            wxURI uri = _request->GetURI();
+            wxString uri_path = uri.GetPath();
+            if (!uri_path.StartsWith("/"))
+            {
+                uri_path.Prepend("/");
+            }
+            return std::string(uri_path.ToStdString());
+        }
+
+        bool request::get_header(const std::string &key, std::string &value) const
+        {
+            wxString header_value = _request->GetHeader(key);
+            bool result(false);
+            if (!header_value.empty())
+            {
+                value = std::string(header_value.ToStdString());
+                result = true;
+            }
+            return result;
+        }
+
+        std::pair<const uint8_t *, size_t> request::get_body() const
+        {
+            const uint8_t *data = reinterpret_cast<const uint8_t *>(_body.GetData().AsCharBuf().data());
+            size_t size = _body.size();
+            return { data, size };
+        }
+
+        void request::read_body(const std::function<void(const uint8_t *, size_t)> &callback) const
+        {
+            const auto& [data, size] = get_body();
+            callback(data, size);
+        }
+    }
+}

src/runtimes/desktop/response.cpp

@@ -0,0 +1,46 @@
+#include <desktop.hpp>
+
+namespace webframe
+{
+    namespace desktop
+    {
+        response::response(wxWebViewHandlerResponse *response, bool &sent) : _response(response), _sent(sent)
+        {
+        }
+
+        void response::set_status(int status)
+        {
+            _response->SetStatus(status);
+        }
+
+        void response::set_header(const std::string &key, const std::string &value)
+        {
+            _response->SetHeader(key, value);
+        }
+
+        void response::set_body(const uint8_t *data, size_t size)
+        {
+            _response->Finish(std::string(reinterpret_cast<const char *>(data), size));
+            _sent = true;
+        }
+
+        void response::write_body(const std::function<bool(std::pair<const uint8_t *, size_t> &)> &callback)
+        {
+            std::vector<uint8_t> buffer;
+            bool has_more_data = true;
+            while (has_more_data)
+            {
+                std::pair<const uint8_t *, size_t> data;
+                if (callback(data))
+                {
+                    buffer.insert(buffer.end(), data.first, data.first + data.second);
+                }
+                else
+                {
+                    has_more_data = false;
+                }
+            }
+            set_body(buffer.data(), buffer.size());
+        }
+    }
+}

src/runtimes/desktop/runtime.cpp

@@ -0,0 +1,86 @@
+#include <desktop.hpp>
+
+class wfApp : public wxApp
+{
+public:
+    void Init(webframe::application *application, webframe::router *router)
+    {
+        _application = application;
+        _router = router;
+    }
+    bool OnInit() override
+    {
+        _application->configure_desktop();
+        _application->configure_router(_router);
+        _frame = std::make_unique<wxFrame>(nullptr, wxID_ANY, "WebFrame");
+        _webview = wxWebView::New(_frame.get(), wxID_ANY, "about:blank", wxDefaultPosition, wxDefaultSize, wxWebViewBackendEdge);
+#ifdef __WXMSW__
+        _webview->Bind(wxEVT_WEBVIEW_NAVIGATING, [](wxWebViewEvent &event)
+                       {
+        const wxString url = event.GetURL();
+        if (!url.StartsWith("https://webframe.ipc"))
+        {
+            event.Skip();
+        } });
+#endif
+        _webview->Bind(wxEVT_WEBVIEW_CREATED, [this](wxWebViewEvent &event)
+        {
+            wxWebView *webview = reinterpret_cast<wxWebView *>(event.GetEventObject());
+            webview->RegisterHandler(wxSharedPtr<wxWebViewHandler>(new webframe::desktop::webview_handler(_router)));
+            webview->LoadURL("https://webframe.ipc/index.html");
+        });
+        _frame->Show();
+        return true;
+    }
+
+private:
+    std::unique_ptr<wxFrame> _frame;
+    wxWebView *_webview;
+    webframe::application *_application;
+    webframe::router *_router;
+};
+
+namespace webframe
+{
+    namespace desktop
+    {
+        int runtime::launch_wx_app(wfApp *app, webframe::application *a, webframe::router *r)
+        {
+            int result(0);
+            app->Init(a, r);
+            if (app->CallOnInit())
+            {
+                a->on_dispatch();
+                result = app->OnRun();
+            }
+            else
+            {
+                result = 1;
+            }
+            wxEntryCleanup();
+            return result;
+        }
+    }
+
+    runtime *webframe_init()
+    {
+        return new desktop::runtime();
+    }
+}
+
+// keep platform specific garbage down here
+wxIMPLEMENT_APP_NO_MAIN(wfApp);
+#ifdef WEBFRAME_WIN32_APP
+#include <wx/msw/init.h>
+int webframe::desktop::runtime::dispatch(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow, webframe::application *a, webframe::router *r)
+{
+    wxEntryStart(hInstance);
+    return launch_wx_app(reinterpret_cast<wfApp *>(wxTheApp), a, r);
+}
+#else
+int webframe::desktop::runtime::dispatch(int argc, const char **argv, webframe::application *a, webframe::router *r)
+{
+    wxEntryStart(argc, const_cast<char **>(argv));
+    return launch_wx_app(reinterpret_cast<wfApp *>(wxTheApp), a, r);
+}
+#endif

src/runtimes/desktop/webview_handler.cpp

@@ -0,0 +1,25 @@
+#include <desktop.hpp>
+
+namespace webframe
+{
+    namespace desktop
+    {
+        webview_handler::webview_handler(webframe::router *router) : wxWebViewHandler("https"), _router(router)
+        {
+            SetVirtualHost("webframe.ipc");
+        }
+
+        void webview_handler::StartRequest(const wxWebViewHandlerRequest& request, wxSharedPtr<wxWebViewHandlerResponse> response)
+        {
+            bool sent(false);
+            webframe::desktop::request req(&request);
+            webframe::desktop::response res(response.get(), sent);
+            webframe::handler *handler = _router->find_route(req.get_path());
+            handler->handle_request(&req, &res);
+            if (!sent)
+            {
+                response->Finish("");
+            }
+        }
+    }
+}