From 955d77ba4a49b6982c5636f576b2fbe871eeb96c Mon Sep 17 00:00:00 2001 From: vczh Date: Sat, 3 Feb 2024 19:39:57 -0800 Subject: [PATCH] Update release --- Import/GacUI.Windows.cpp | 6 +- Import/GacUI.cpp | 2166 ++++++++++++++++- Import/GacUI.h | 1046 +++++++- Import/GacUICompiler.cpp | 1819 ++++++++++++++ Import/GacUICompiler.h | 551 +++++ Import/VlppReflection.cpp | 1 - Import/VlppReflection.h | 3 +- Tools/Reflection32.bin | Bin 948216 -> 948797 bytes Tools/Reflection64.bin | Bin 948216 -> 948797 bytes .../GacUI_ControlTemplate/UIRes/BlackSkin.bin | Bin 93695 -> 95527 bytes .../GacUI_Controls/UIRes/DocumentEditor.bin | Bin 35790 -> 37622 bytes .../UIRes/DocumentEditorRibbon.bin | Bin 35924 -> 37756 bytes .../UIRes/DocumentEditorToolstrip.bin | Bin 35889 -> 37721 bytes .../UIRes/Win11ToolstripMenu.bin | Bin 35494 -> 37326 bytes Tutorial/GacUI_HelloWorlds/UIRes/Xml.bin.x64 | Bin 25176 -> 25176 bytes Tutorial/GacUI_HelloWorlds/UIRes/Xml.bin.x86 | Bin 25176 -> 25176 bytes 16 files changed, 5485 insertions(+), 107 deletions(-) diff --git a/Import/GacUI.Windows.cpp b/Import/GacUI.Windows.cpp index 7a89d957..f67c98f7 100644 --- a/Import/GacUI.Windows.cpp +++ b/Import/GacUI.Windows.cpp @@ -2695,7 +2695,7 @@ ControllerListener d3d11Device = CreateD3D11Device(D3D_DRIVER_TYPE_WARP); } } -#if _DEBUG +#ifdef _DEBUG CHECK_ERROR(d3d11Device, L"Direct2DWindowsNativeControllerListener::NativeWindowCreated(INativeWindow*)#" L"Failed to create Direct3D 11 Device. " @@ -14364,7 +14364,7 @@ WindowsInputService WindowsInputService::WindowsInputService() :ownerHandle(NULL) ,isTimerEnabled(false) - ,keyNames(146) + ,keyNames((vint)VKEY::KEY_MAXIMUM) { InitializeKeyNames(); } @@ -14415,7 +14415,7 @@ WindowsInputService } else { - return L"?"; + return WString::Unmanaged(L"?"); } } diff --git a/Import/GacUI.cpp b/Import/GacUI.cpp index 40061990..71ac091b 100644 --- a/Import/GacUI.cpp +++ b/Import/GacUI.cpp @@ -1202,12 +1202,13 @@ GuiControl void GuiControl::SetFocused() { - if (focusableComposition) + if (!focusableComposition) return; + if (!isVisuallyEnabled) return; + if (!focusableComposition->GetEventuallyVisible()) return; + + if (auto host = focusableComposition->GetRelatedGraphicsHost()) { - if (auto host = focusableComposition->GetRelatedGraphicsHost()) - { - host->SetFocus(focusableComposition); - } + host->SetFocus(focusableComposition); } } @@ -4404,18 +4405,22 @@ GuiGraphicsHost void GuiGraphicsHost::OnCharInput(const NativeWindowCharInfo& info, GuiGraphicsComposition* composition, GuiCharEvent GuiGraphicsEventReceiver::* eventReceiverEvent) { List compositions; - while(composition) + GuiCharEventArgs arguments(composition); + (NativeWindowCharInfo&)arguments = info; + + while (composition) { - if(composition->HasEventReceiver()) + if (composition->HasEventReceiver()) { + if (!arguments.eventSource) + { + arguments.eventSource = composition; + } compositions.Add(composition); } - composition=composition->GetParent(); + composition = composition->GetParent(); } - GuiCharEventArgs arguments(composition); - (NativeWindowCharInfo&)arguments=info; - // TODO: (enumerable) foreach:reversed for(vint i=compositions.Count()-1;i>=0;i--) { @@ -4440,21 +4445,22 @@ GuiGraphicsHost void GuiGraphicsHost::OnKeyInput(const NativeWindowKeyInfo& info, GuiGraphicsComposition* composition, GuiKeyEvent GuiGraphicsEventReceiver::* eventReceiverEvent) { List compositions; + GuiKeyEventArgs arguments(composition); + (NativeWindowKeyInfo&)arguments = info; + + while (composition) { - auto current = composition; - while (current) + if (composition->HasEventReceiver()) { - if (current->HasEventReceiver()) + if (!arguments.eventSource) { - compositions.Add(current); + arguments.eventSource = composition; } - current = current->GetParent(); + compositions.Add(composition); } + composition = composition->GetParent(); } - GuiKeyEventArgs arguments(composition); - (NativeWindowKeyInfo&)arguments = info; - // TODO: (enumerable) foreach:reversed for (vint i = compositions.Count() - 1; i >= 0; i--) { @@ -4671,7 +4677,8 @@ GuiGraphicsHost void GuiGraphicsHost::LeftButtonDoubleClick(const NativeWindowMouseInfo& info) { - LeftButtonDown(info); + altActionManager->CloseAltHost(); + OnMouseInput(info, false, false, &GuiGraphicsEventReceiver::leftButtonDown); OnMouseInput(info, false, false, &GuiGraphicsEventReceiver::leftButtonDoubleClick); } @@ -4688,7 +4695,8 @@ GuiGraphicsHost void GuiGraphicsHost::RightButtonDoubleClick(const NativeWindowMouseInfo& info) { - RightButtonDown(info); + altActionManager->CloseAltHost(); + OnMouseInput(info, false, false, &GuiGraphicsEventReceiver::rightButtonDown); OnMouseInput(info, false, false, &GuiGraphicsEventReceiver::rightButtonDoubleClick); } @@ -4705,7 +4713,8 @@ GuiGraphicsHost void GuiGraphicsHost::MiddleButtonDoubleClick(const NativeWindowMouseInfo& info) { - MiddleButtonDown(info); + altActionManager->CloseAltHost(); + OnMouseInput(info, false, false, &GuiGraphicsEventReceiver::middleButtonDown); OnMouseInput(info, false, false, &GuiGraphicsEventReceiver::middleButtonDoubleClick); } @@ -4793,10 +4802,10 @@ GuiGraphicsHost void GuiGraphicsHost::MouseLeaved() { // TODO: (enumerable) foreach:reversed - for(vint i=mouseEnterCompositions.Count()-1;i>=0;i--) + for (vint i = mouseEnterCompositions.Count() - 1; i >= 0; i--) { - GuiGraphicsComposition* composition=mouseEnterCompositions[i]; - if(composition->HasEventReceiver()) + GuiGraphicsComposition* composition = mouseEnterCompositions[i]; + if (composition->HasEventReceiver()) { composition->GetEventReceiver()->mouseLeave.Execute(GuiEventArgs(composition)); } @@ -4810,9 +4819,13 @@ GuiGraphicsHost if (tabActionManager->KeyDown(info, focusedComposition)) { return; } if(shortcutKeyManager && shortcutKeyManager->Execute(info)) { return; } - if (focusedComposition && focusedComposition->HasEventReceiver()) + auto receiver = focusedComposition; + if (!receiver) receiver = controlHost->GetFocusableComposition(); + if (!receiver) receiver = controlHost->GetBoundsComposition(); + + if (receiver && receiver->HasEventReceiver()) { - OnKeyInput(info, focusedComposition, &GuiGraphicsEventReceiver::keyDown); + OnKeyInput(info, receiver, &GuiGraphicsEventReceiver::keyDown); } } @@ -4824,9 +4837,13 @@ GuiGraphicsHost hostRecord.nativeWindow->SupressAlt(); } - if(focusedComposition && focusedComposition->HasEventReceiver()) + auto receiver = focusedComposition; + if (!receiver) receiver = controlHost->GetFocusableComposition(); + if (!receiver) receiver = controlHost->GetBoundsComposition(); + + if(receiver && receiver->HasEventReceiver()) { - OnKeyInput(info, focusedComposition, &GuiGraphicsEventReceiver::keyUp); + OnKeyInput(info, receiver, &GuiGraphicsEventReceiver::keyUp); } } @@ -4835,9 +4852,13 @@ GuiGraphicsHost if (altActionManager->Char(info)) { return; } if (tabActionManager->Char(info)) { return; } - if(focusedComposition && focusedComposition->HasEventReceiver()) + auto receiver = focusedComposition; + if (!receiver) receiver = controlHost->GetFocusableComposition(); + if (!receiver) receiver = controlHost->GetBoundsComposition(); + + if(receiver && receiver->HasEventReceiver()) { - OnCharInput(info, focusedComposition, &GuiGraphicsEventReceiver::charInput); + OnCharInput(info, receiver, &GuiGraphicsEventReceiver::charInput); } } @@ -25821,7 +25842,10 @@ GuiToolstripCommand void GuiToolstripCommand::OnShortcutKeyItemExecuted(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) { - Executed.ExecuteWithNewSender(arguments, sender); + if (enabled) + { + Executed.ExecuteWithNewSender(arguments, sender); + } } void GuiToolstripCommand::OnRenderTargetChanged(compositions::GuiGraphicsComposition* sender, compositions::GuiEventArgs& arguments) @@ -35295,6 +35319,7 @@ GuiHostedController::WindowManager void GuiHostedController::OnGotFocus(hosted_window_manager::Window* window) { + window->id->BecomeFocusedWindow(); for (auto listener : window->id->listeners) { listener->GotFocus(); @@ -35303,7 +35328,6 @@ GuiHostedController::WindowManager void GuiHostedController::OnLostFocus(hosted_window_manager::Window* window) { - window->id->BecomeFocusedWindow(); for (auto listener : window->id->listeners) { listener->LostFocus(); @@ -35891,36 +35915,28 @@ GuiHostedController::INativeControllerListener bool failureByResized = false; bool failureByLostDevice = false; - // TODO: (enumerable) foreach:reversed - for (vint i = wmManager->ordinaryWindowsInOrder.Count() - 1; i >= 0; i--) - { - auto hostedWindow = wmManager->ordinaryWindowsInOrder[i]->id; - for (auto listener : hostedWindow->listeners) - { - bool updated = false; - listener->ForceRefresh(false, updated, failureByResized, failureByLostDevice); - windowsUpdatedInLastFrame |= updated; - if (failureByResized || failureByLostDevice) - { - goto STOP_RENDERING; - } - } - } - // TODO: (enumerable) foreach:reversed - for (vint i = wmManager->topMostedWindowsInOrder.Count() - 1; i >= 0; i--) + auto forceRefreshWindows = [&](List*>& windows) { - auto hostedWindow = wmManager->topMostedWindowsInOrder[i]->id; - for (auto listener : hostedWindow->listeners) + // TODO: (enumerable) foreach:reversed + for (vint i = windows.Count() - 1; i >= 0; i--) { - bool updated = false; - listener->ForceRefresh(false, updated, failureByResized, failureByLostDevice); - windowsUpdatedInLastFrame |= updated; - if (failureByResized || failureByLostDevice) + auto hostedWindow = windows[i]->id; + for (auto listener : hostedWindow->listeners) { - goto STOP_RENDERING; + bool updated = false; + listener->ForceRefresh(false, updated, failureByResized, failureByLostDevice); + windowsUpdatedInLastFrame |= updated; + if (failureByResized || failureByLostDevice) + { + return false; + } } } - } + return true; + }; + + if (!forceRefreshWindows(wmManager->ordinaryWindowsInOrder)) goto STOP_RENDERING; + if (!forceRefreshWindows(wmManager->topMostedWindowsInOrder)) goto STOP_RENDERING; STOP_RENDERING: switch (renderTarget->StopHostedRendering()) @@ -36184,7 +36200,10 @@ GuiHostedController::INativeWindowService { if (nativeWindow) { - wmManager->Stop(); + if (wmManager->mainWindow) + { + wmManager->Stop(); + } // TODO: (enumerable) foreach:indexed(alterable(reversed)) for (vint i = createdWindows.Count() - 1; i >= 0; i--) @@ -36412,7 +36431,7 @@ GuiHostedWindow void GuiHostedWindow::BecomeNonMainWindow() { - proxy = CreateNonMainHostedWindowProxy(this); + proxy = CreateNonMainHostedWindowProxy(this, controller->nativeWindow); proxy->CheckAndSyncProperties(); } @@ -36645,15 +36664,21 @@ GuiHostedWindow void GuiHostedWindow::Hide(bool closeWindow) { - bool cancel = false; - for (auto listener : listeners) - { - listener->BeforeClosing(cancel); - if (cancel) return; - } - for (auto listener : listeners) + if (!wmWindow.visible) return; + + if (this != controller->mainWindow) { - listener->AfterClosing(); + // for main window, the underlying INativeWindow will run the process + bool cancel = false; + for (auto listener : listeners) + { + listener->BeforeClosing(cancel); + if (cancel) return; + } + for (auto listener : listeners) + { + listener->AfterClosing(); + } } if (closeWindow) @@ -37130,12 +37155,14 @@ GuiNonMainHostedWindowProxy { protected: GuiHostedWindowData* data = nullptr; + INativeWindow* nativeWindow = nullptr; bool calledAssignFrameConfig = false; public: - GuiNonMainHostedWindowProxy(GuiHostedWindowData* _data) + GuiNonMainHostedWindowProxy(GuiHostedWindowData* _data, INativeWindow* _nativeWindow) : data(_data) + , nativeWindow(_nativeWindow) { } @@ -37306,7 +37333,11 @@ GuiNonMainHostedWindowProxy void SetFocus() override { - data->wmWindow.Activate(); + if (data->wmWindow.visible) + { + data->wmWindow.Activate(); + nativeWindow->SetActivate(); + } } }; @@ -37314,9 +37345,9 @@ GuiNonMainHostedWindowProxy Helper ***********************************************************************/ - Ptr CreateNonMainHostedWindowProxy(GuiHostedWindowData* data) + Ptr CreateNonMainHostedWindowProxy(GuiHostedWindowData* data, INativeWindow* nativeWindow) { - return Ptr(new GuiNonMainHostedWindowProxy(data)); + return Ptr(new GuiNonMainHostedWindowProxy(data, nativeWindow)); } } } @@ -37478,6 +37509,1997 @@ Helper } } +/*********************************************************************** +.\PLATFORMPROVIDERS\REMOTE\GUIREMOTECONTROLLER.CPP +***********************************************************************/ + +namespace vl::presentation +{ + using namespace collections; + +/*********************************************************************** +GuiRemoteCursor +***********************************************************************/ + + class GuiRemoteCursor : public Object, public virtual INativeCursor + { + protected: + INativeCursor::SystemCursorType cursorType; + + public: + GuiRemoteCursor(INativeCursor::SystemCursorType _cursorType) : cursorType(_cursorType) {} + + bool IsSystemCursor() { return true; } + SystemCursorType GetSystemCursorType() { return cursorType; } + }; + +/*********************************************************************** +GuiRemoteController::INativeResourceService +***********************************************************************/ + + INativeCursor* GuiRemoteController::GetSystemCursor(INativeCursor::SystemCursorType type) + { + vint index = cursors.Keys().IndexOf(type); + if (index == -1) + { + auto cursor = Ptr(new GuiRemoteCursor(type)); + cursors.Add(type, cursor); + return cursor.Obj(); + } + else + { + return cursors.Values()[index].Obj(); + } + } + + INativeCursor* GuiRemoteController::GetDefaultSystemCursor() + { + return GetSystemCursor(INativeCursor::SystemCursorType::Arrow); + } + + FontProperties GuiRemoteController::GetDefaultFont() + { + return remoteFontConfig.defaultFont; + } + + void GuiRemoteController::SetDefaultFont(const FontProperties& value) + { + remoteFontConfig.defaultFont = value; + } + + void GuiRemoteController::EnumerateFonts(collections::List& fonts) + { + if (remoteFontConfig.supportedFonts) + { + CopyFrom(fonts, *remoteFontConfig.supportedFonts.Obj()); + } + } + +/*********************************************************************** +GuiRemoteController::INativeInputService +***********************************************************************/ + + void GuiRemoteController::StartTimer() + { + timerEnabled = true; + } + + void GuiRemoteController::StopTimer() + { + timerEnabled = false; + } + + bool GuiRemoteController::IsTimerEnabled() + { + return timerEnabled; + } + + bool GuiRemoteController::IsKeyPressing(VKEY code) + { + vint idIsKeyPressing = remoteMessages.RequestIOIsKeyPressing(code); + remoteMessages.Submit(); + bool result = remoteMessages.RetrieveIOIsKeyPressing(idIsKeyPressing); + remoteMessages.ClearResponses(); + return result; + } + + bool GuiRemoteController::IsKeyToggled(VKEY code) + { + vint idIsKeyToggled = remoteMessages.RequestIOIsKeyToggled(code); + remoteMessages.Submit(); + bool result = remoteMessages.RetrieveIOIsKeyToggled(idIsKeyToggled); + remoteMessages.ClearResponses(); + return result; + } + + void GuiRemoteController::EnsureKeyInitialized() + { + if (keyInitialized) return; + keyInitialized = true; + +#define INITIALIZE_KEY_NAME(NAME, TEXT)\ + keyNames.Add(VKEY::KEY_ ## NAME, WString::Unmanaged(TEXT));\ + if (!keyCodes.Keys().Contains(WString::Unmanaged(TEXT))) keyCodes.Add(WString::Unmanaged(TEXT), VKEY::KEY_ ## NAME);\ + + GUI_DEFINE_KEYBOARD_WINDOWS_NAME(INITIALIZE_KEY_NAME) +#undef INITIALIZE_KEY_NAME + } + + WString GuiRemoteController::GetKeyName(VKEY code) + { + EnsureKeyInitialized(); + vint index = keyNames.Keys().IndexOf(code); + return index == -1 ? WString::Unmanaged(L"?") : keyNames.Values()[index]; + } + + VKEY GuiRemoteController::GetKey(const WString& name) + { + EnsureKeyInitialized(); + vint index = keyCodes.Keys().IndexOf(name); + return index == -1 ? VKEY::KEY_UNKNOWN : keyCodes.Values()[index]; + } + + void GuiRemoteController::UpdateGlobalShortcutKey() + { + auto hotKeys = Ptr(new List); + for (auto [id, entry] : hotKeyIds) + { + remoteprotocol::GlobalShortcutKey key; + key.id = id; + key.ctrl = entry.get<0>(); + key.shift = entry.get<1>(); + key.alt = entry.get<2>(); + key.code = entry.get<3>(); + hotKeys->Add(key); + } + remoteMessages.RequestIOUpdateGlobalShortcutKey(hotKeys); + } + + vint GuiRemoteController::RegisterGlobalShortcutKey(bool ctrl, bool shift, bool alt, VKEY key) + { + HotKeyEntry entry = { ctrl,shift,alt,key }; + if (hotKeySet.Contains(entry)) return (vint)NativeGlobalShortcutKeyResult::Occupied; + + vint id = ++usedHotKeys; + hotKeySet.Add(entry); + hotKeyIds.Add(id, entry); + + UpdateGlobalShortcutKey(); + remoteMessages.Submit(); + + return id; + } + + bool GuiRemoteController::UnregisterGlobalShortcutKey(vint id) + { + vint index = hotKeyIds.Keys().IndexOf(id); + if (index == -1) return false; + + auto entry = hotKeyIds.Values()[index]; + hotKeyIds.Remove(id); + hotKeySet.Remove(entry); + + UpdateGlobalShortcutKey(); + remoteMessages.Submit(); + + return true; + } + +/*********************************************************************** +GuiRemoteController::INativeScreenService +***********************************************************************/ + + vint GuiRemoteController::GetScreenCount() + { + return 1; + } + + INativeScreen* GuiRemoteController::GetScreen(vint index) + { + CHECK_ERROR(index == 0, L"vl::presentation::GuiRemoteController::GetScreen(vint)#Index out of range."); + return this; + } + + INativeScreen* GuiRemoteController::GetScreen(INativeWindow* window) + { + return this; + } + +/*********************************************************************** +GuiHostedController::INativeScreen +***********************************************************************/ + + NativeRect GuiRemoteController::GetBounds() + { + return remoteScreenConfig.bounds; + } + + NativeRect GuiRemoteController::GetClientBounds() + { + return remoteScreenConfig.clientBounds; + } + + WString GuiRemoteController::GetName() + { + return WString::Unmanaged(L"GacUI Virtual Remote Screen"); + } + + bool GuiRemoteController::IsPrimary() + { + return true; + } + + double GuiRemoteController::GetScalingX() + { + return remoteScreenConfig.scalingX; + } + + double GuiRemoteController::GetScalingY() + { + return remoteScreenConfig.scalingY; + } + +/*********************************************************************** +GuiRemoteController::INativeWindowService +***********************************************************************/ + + const NativeWindowFrameConfig& GuiRemoteController::GetMainWindowFrameConfig() + { + return NativeWindowFrameConfig::Default; + } + + const NativeWindowFrameConfig& GuiRemoteController::GetNonMainWindowFrameConfig() + { + return NativeWindowFrameConfig::Default; + } + + INativeWindow* GuiRemoteController::CreateNativeWindow(INativeWindow::WindowMode windowMode) + { + CHECK_ERROR(!windowCreated, L"vl::presentation::GuiRemoteController::CreateNativeWindow(INativeWindow::WindowMode)#GuiHostedController is not supposed to call this function for twice."); + windowCreated = true; + remoteWindow.windowMode = windowMode; + callbackService.InvokeNativeWindowCreated(&remoteWindow); + return &remoteWindow; + } + + void GuiRemoteController::DestroyNativeWindow(INativeWindow* window) + { + CHECK_ERROR(!windowDestroyed, L"vl::presentation::GuiRemoteController::CreateNativeWindow(INativeWindow::WindowMode)#GuiHostedController is not supposed to call this function for twice."); + windowDestroyed = true; + + for (auto l : remoteWindow.listeners) l->Closed(); + for (auto l : remoteWindow.listeners) l->Destroying(); + callbackService.InvokeNativeWindowDestroying(&remoteWindow); + for (auto l : remoteWindow.listeners) l->Destroyed(); + connectionStopped = true; + } + + INativeWindow* GuiRemoteController::GetMainWindow() + { + return windowCreated && !windowDestroyed ? &remoteWindow : nullptr; + } + + INativeWindow* GuiRemoteController::GetWindow(NativePoint location) + { + return GetMainWindow(); + } + + void GuiRemoteController::Run(INativeWindow* window) + { + CHECK_ERROR(window == &remoteWindow, L"vl::presentation::GuiRemoteController::Run(INativeWindow*)#GuiHostedController should call this function with the native window."); + applicationRunning = true; + window->Show(); + while (RunOneCycle()); + applicationRunning = false; + } + + bool GuiRemoteController::RunOneCycle() + { + if (!connectionStopped) + { + remoteProtocol->ProcessRemoteEvents(); + remoteMessages.Submit(); + } + return !connectionStopped; + } + +/*********************************************************************** +GuiRemoteController (events) +***********************************************************************/ + + void GuiRemoteController::OnControllerConnect() + { + UpdateGlobalShortcutKey(); + vint idGetFontConfig = remoteMessages.RequestControllerGetFontConfig(); + vint idGetScreenConfig = remoteMessages.RequestControllerGetScreenConfig(); + remoteMessages.Submit(); + remoteFontConfig = remoteMessages.RetrieveControllerGetFontConfig(idGetFontConfig); + remoteScreenConfig = remoteMessages.RetrieveControllerGetScreenConfig(idGetScreenConfig); + remoteMessages.ClearResponses(); + remoteWindow.OnControllerConnect(); + } + + void GuiRemoteController::OnControllerDisconnect() + { + remoteWindow.OnControllerDisconnect(); + } + + void GuiRemoteController::OnControllerRequestExit() + { + remoteWindow.Hide(true); + } + + void GuiRemoteController::OnControllerForceExit() + { + connectionForcedToStop = true; + remoteWindow.Hide(true); + } + + void GuiRemoteController::OnControllerScreenUpdated(const remoteprotocol::ScreenConfig& arguments) + { + remoteScreenConfig = arguments; + } + +/*********************************************************************** +GuiRemoteController +***********************************************************************/ + + GuiRemoteController::GuiRemoteController(IGuiRemoteProtocol* _remoteProtocol) + : remoteProtocol(_remoteProtocol) + , remoteMessages(this) + , remoteEvents(this) + , remoteWindow(this) + { + } + + GuiRemoteController::~GuiRemoteController() + { + } + + void GuiRemoteController::Initialize() + { + remoteProtocol->Initialize(&remoteEvents); + } + + void GuiRemoteController::Finalize() + { + remoteMessages.RequestControllerConnectionStopped(); + remoteMessages.Submit(); + } + +/*********************************************************************** +GuiRemoteController (INativeController) +***********************************************************************/ + + INativeCallbackService* GuiRemoteController::CallbackService() + { + return &callbackService; + } + + INativeResourceService* GuiRemoteController::ResourceService() + { + return this; + } + + INativeAsyncService* GuiRemoteController::AsyncService() + { + return &asyncService; + } + + INativeClipboardService* GuiRemoteController::ClipboardService() + { + CHECK_FAIL(L"Not Implemented!"); + } + + INativeImageService* GuiRemoteController::ImageService() + { + CHECK_FAIL(L"Not Implemented!"); + } + + INativeInputService* GuiRemoteController::InputService() + { + return this; + } + + INativeDialogService* GuiRemoteController::DialogService() + { + // Use FakeDialogServiceBase + return nullptr; + } + + WString GuiRemoteController::GetExecutablePath() + { + return remoteProtocol->GetExecutablePath(); + } + + INativeScreenService* GuiRemoteController::ScreenService() + { + return this; + } + + INativeWindowService* GuiRemoteController::WindowService() + { + return this; + } +} + +/*********************************************************************** +.\PLATFORMPROVIDERS\REMOTE\GUIREMOTECONTROLLERSETUP.CPP +***********************************************************************/ + +using namespace vl; +using namespace vl::presentation; +using namespace vl::presentation::elements; + +/*********************************************************************** +SetupRemoteNativeController +***********************************************************************/ + +extern void GuiApplicationMain(); + +int SetupRemoteNativeController(vl::presentation::IGuiRemoteProtocol* protocol) +{ + GuiRemoteController remoteController(protocol); + GuiRemoteGraphicsResourceManager remoteResourceManager(&remoteController); + + GuiHostedController hostedController(&remoteController); + GuiHostedGraphicsResourceManager hostedResourceManager(&hostedController, &remoteResourceManager); + + SetNativeController(&hostedController); + SetGuiGraphicsResourceManager(&hostedResourceManager); + + remoteController.Initialize(); + hostedController.Initialize(); + GuiApplicationMain(); + hostedController.Finalize(); + remoteController.Finalize(); + + SetGuiGraphicsResourceManager(nullptr); + SetNativeController(nullptr); + return 0; +} + +/*********************************************************************** +.\PLATFORMPROVIDERS\REMOTE\GUIREMOTEEVENTS.CPP +***********************************************************************/ + +namespace vl::presentation +{ + +/*********************************************************************** +GuiRemoteMessages +***********************************************************************/ + + GuiRemoteMessages::GuiRemoteMessages(GuiRemoteController* _remote) + : remote(_remote) + { + } + + GuiRemoteMessages::~GuiRemoteMessages() + { + } + + void GuiRemoteMessages::Submit() + { + remote->remoteProtocol->Submit(); + } + + void GuiRemoteMessages::ClearResponses() + { +#define MESSAGE_NORES(NAME, RESPONSE) +#define MESSAGE_RES(NAME, RESPONSE) response ## NAME.Clear(); +#define MESSAGE_HANDLER(NAME, REQUEST, RESPONSE, REQTAG, RESTAG, ...) MESSAGE_ ## RESTAG(NAME, RESPONSE) + GACUI_REMOTEPROTOCOL_MESSAGES(MESSAGE_HANDLER) +#undef MESSAGE_HANDLER +#undef MESSAGE_RES +#undef MESSAGE_NORES + } + +/*********************************************************************** +GuiRemoteMessages (messages) +***********************************************************************/ + +#define MESSAGE_NOREQ_NORES(NAME, REQUEST, RESPONSE)\ + void GuiRemoteMessages::Request ## NAME()\ + {\ + remote->remoteProtocol->Request ## NAME();\ + }\ + +#define MESSAGE_NOREQ_RES(NAME, REQUEST, RESPONSE)\ + vint GuiRemoteMessages::Request ## NAME()\ + {\ + vint requestId = ++id;\ + remote->remoteProtocol->Request ## NAME(requestId);\ + return requestId;\ + }\ + +#define MESSAGE_REQ_NORES(NAME, REQUEST, RESPONSE)\ + void GuiRemoteMessages::Request ## NAME(const REQUEST& arguments)\ + {\ + remote->remoteProtocol->Request ## NAME(arguments);\ + }\ + +#define MESSAGE_REQ_RES(NAME, REQUEST, RESPONSE)\ + vint GuiRemoteMessages::Request ## NAME(const REQUEST& arguments)\ + {\ + vint requestId = ++id;\ + remote->remoteProtocol->Request ## NAME(requestId, arguments);\ + return requestId;\ + }\ + +#define MESSAGE_HANDLER(NAME, REQUEST, RESPONSE, REQTAG, RESTAG, ...) MESSAGE_ ## REQTAG ## _ ## RESTAG(NAME, REQUEST, RESPONSE) + GACUI_REMOTEPROTOCOL_MESSAGES(MESSAGE_HANDLER) +#undef MESSAGE_HANDLER +#undef MESSAGE_REQ_RES +#undef MESSAGE_REQ_NORES +#undef MESSAGE_NOREQ_RES +#undef MESSAGE_NOREQ_NORES + +#define MESSAGE_NORES(NAME, RESPONSE) +#define MESSAGE_RES(NAME, RESPONSE)\ + void GuiRemoteMessages::Respond ## NAME(vint id, const RESPONSE& arguments)\ + {\ + response ## NAME.Add(id, arguments);\ + }\ + const RESPONSE& GuiRemoteMessages::Retrieve ## NAME(vint id)\ + {\ + return response ## NAME[id];\ + }\ + +#define MESSAGE_HANDLER(NAME, REQUEST, RESPONSE, REQTAG, RESTAG, ...) MESSAGE_ ## RESTAG(NAME, RESPONSE) + GACUI_REMOTEPROTOCOL_MESSAGES(MESSAGE_HANDLER) +#undef MESSAGE_HANDLER +#undef MESSAGE_RES +#undef MESSAGE_NORES + +/*********************************************************************** +GuiRemoteEvents +***********************************************************************/ + + GuiRemoteEvents::GuiRemoteEvents(GuiRemoteController* _remote) + : remote(_remote) + { + } + + GuiRemoteEvents::~GuiRemoteEvents() + { + } + +/*********************************************************************** +GuiRemoteEvents (messages) +***********************************************************************/ + +#define MESSAGE_NORES(NAME, RESPONSE) +#define MESSAGE_RES(NAME, RESPONSE)\ + void GuiRemoteEvents::Respond ## NAME(vint id, const RESPONSE& arguments)\ + {\ + remote->remoteMessages.Respond ## NAME(id, arguments);\ + }\ + +#define MESSAGE_HANDLER(NAME, REQUEST, RESPONSE, REQTAG, RESTAG, ...) MESSAGE_ ## RESTAG(NAME, RESPONSE) + GACUI_REMOTEPROTOCOL_MESSAGES(MESSAGE_HANDLER) +#undef MESSAGE_HANDLER +#undef MESSAGE_RES +#undef MESSAGE_NORES + +/*********************************************************************** +GuiRemoteEvents (events) +***********************************************************************/ + + void GuiRemoteEvents::OnControllerConnect() + { + remote->OnControllerConnect(); + remote->remoteMessages.RequestControllerConnectionEstablished(); + remote->remoteMessages.Submit(); + } + + void GuiRemoteEvents::OnControllerDisconnect() + { + remote->OnControllerDisconnect(); + } + + void GuiRemoteEvents::OnControllerRequestExit() + { + remote->OnControllerRequestExit(); + } + + void GuiRemoteEvents::OnControllerForceExit() + { + remote->OnControllerForceExit(); + } + + void GuiRemoteEvents::OnControllerScreenUpdated(const remoteprotocol::ScreenConfig& arguments) + { + remote->OnControllerScreenUpdated(arguments); + } + + void GuiRemoteEvents::OnWindowBoundsUpdated(const remoteprotocol::WindowSizingConfig& arguments) + { + remote->remoteWindow.OnWindowBoundsUpdated(arguments); + } + + void GuiRemoteEvents::OnWindowActivatedUpdated(const bool& arguments) + { + remote->remoteWindow.OnWindowActivatedUpdated(arguments); + } + + void GuiRemoteEvents::OnIOGlobalShortcutKey(const vint& arguments) + { + remote->callbackService.InvokeGlobalShortcutKeyActivated(arguments); + } + + void GuiRemoteEvents::OnIOButtonDown(const remoteprotocol::IOMouseInfoWithButton& arguments) + { + switch (arguments.button) + { + case remoteprotocol::IOMouseButton::Left: + for (auto l : remote->remoteWindow.listeners) l->LeftButtonDown(arguments.info); + break; + case remoteprotocol::IOMouseButton::Middle: + for (auto l : remote->remoteWindow.listeners) l->MiddleButtonDown(arguments.info); + break; + case remoteprotocol::IOMouseButton::Right: + for (auto l : remote->remoteWindow.listeners) l->RightButtonDown(arguments.info); + break; + default: + CHECK_FAIL(L"vl::presentation::GuiRemoteEvents::OnIOButtonDown(const IOMouseInfoWithButton&)#Unrecognized button."); + } + } + + void GuiRemoteEvents::OnIOButtonDoubleClick(const remoteprotocol::IOMouseInfoWithButton& arguments) + { + switch (arguments.button) + { + case remoteprotocol::IOMouseButton::Left: + for (auto l : remote->remoteWindow.listeners) l->LeftButtonDoubleClick(arguments.info); + break; + case remoteprotocol::IOMouseButton::Middle: + for (auto l : remote->remoteWindow.listeners) l->MiddleButtonDoubleClick(arguments.info); + break; + case remoteprotocol::IOMouseButton::Right: + for (auto l : remote->remoteWindow.listeners) l->RightButtonDoubleClick(arguments.info); + break; + default: + CHECK_FAIL(L"vl::presentation::GuiRemoteEvents::OnIOButtonDoubleClick(const IOMouseInfoWithButton&)#Unrecognized button."); + } + } + + void GuiRemoteEvents::OnIOButtonUp(const remoteprotocol::IOMouseInfoWithButton& arguments) + { + switch (arguments.button) + { + case remoteprotocol::IOMouseButton::Left: + for (auto l : remote->remoteWindow.listeners) l->LeftButtonUp(arguments.info); + break; + case remoteprotocol::IOMouseButton::Middle: + for (auto l : remote->remoteWindow.listeners) l->MiddleButtonUp(arguments.info); + break; + case remoteprotocol::IOMouseButton::Right: + for (auto l : remote->remoteWindow.listeners) l->RightButtonUp(arguments.info); + break; + default: + CHECK_FAIL(L"vl::presentation::GuiRemoteEvents::OnIOButtonUp(const IOMouseInfoWithButton&)#Unrecognized button."); + } + } + + void GuiRemoteEvents::OnIOHWheel(const NativeWindowMouseInfo& arguments) + { + for (auto l : remote->remoteWindow.listeners) l->HorizontalWheel(arguments); + } + + void GuiRemoteEvents::OnIOVWheel(const NativeWindowMouseInfo& arguments) + { + for (auto l : remote->remoteWindow.listeners) l->VerticalWheel(arguments); + } + + void GuiRemoteEvents::OnIOMouseMoving(const NativeWindowMouseInfo& arguments) + { + for (auto l : remote->remoteWindow.listeners) l->MouseMoving(arguments); + } + + void GuiRemoteEvents::OnIOMouseEntered() + { + for (auto l : remote->remoteWindow.listeners) l->MouseEntered(); + } + + void GuiRemoteEvents::OnIOMouseLeaved() + { + for (auto l : remote->remoteWindow.listeners) l->MouseLeaved(); + } + + void GuiRemoteEvents::OnIOKeyDown(const NativeWindowKeyInfo& arguments) + { + for (auto l : remote->remoteWindow.listeners) l->KeyDown(arguments); + } + + void GuiRemoteEvents::OnIOKeyUp(const NativeWindowKeyInfo& arguments) + { + for (auto l : remote->remoteWindow.listeners) l->KeyUp(arguments); + } + + void GuiRemoteEvents::OnIOChar(const NativeWindowCharInfo& arguments) + { + for (auto l : remote->remoteWindow.listeners) l->Char(arguments); + } +} + +/*********************************************************************** +.\PLATFORMPROVIDERS\REMOTE\GUIREMOTEGRAPHICS.CPP +***********************************************************************/ + +namespace vl::presentation::elements +{ + +/*********************************************************************** +GuiRemoteGraphicsRenderTarget +***********************************************************************/ + + void GuiRemoteGraphicsRenderTarget::StartRenderingOnNativeWindow() + { + canvasSize = remote->remoteWindow.GetClientSize(); + } + + RenderTargetFailure GuiRemoteGraphicsRenderTarget::StopRenderingOnNativeWindow() + { + if (canvasSize == remote->remoteWindow.GetClientSize()) + { + return RenderTargetFailure::None; + } + else + { + return RenderTargetFailure::ResizeWhileRendering; + } + } + + Size GuiRemoteGraphicsRenderTarget::GetCanvasSize() + { + return remote->remoteWindow.Convert(canvasSize); + } + + void GuiRemoteGraphicsRenderTarget::AfterPushedClipper(Rect clipper, Rect validArea) + { + } + + void GuiRemoteGraphicsRenderTarget::AfterPushedClipperAndBecameInvalid(Rect clipper) + { + } + + void GuiRemoteGraphicsRenderTarget::AfterPoppedClipperAndBecameValid(Rect validArea, bool clipperExists) + { + } + + void GuiRemoteGraphicsRenderTarget::AfterPoppedClipper(Rect validArea, bool clipperExists) + { + } + + GuiRemoteGraphicsRenderTarget::GuiRemoteGraphicsRenderTarget(GuiRemoteController* _remote) + : remote(_remote) + { + } + + GuiRemoteGraphicsRenderTarget::~GuiRemoteGraphicsRenderTarget() + { + } + +/*********************************************************************** +GuiRemoteGraphicsResourceManager +***********************************************************************/ + + GuiRemoteGraphicsResourceManager::GuiRemoteGraphicsResourceManager(GuiRemoteController* _remote) + : remote(_remote) + , renderTarget(_remote) + { + // TODO: register element renderers; + } + + GuiRemoteGraphicsResourceManager::~GuiRemoteGraphicsResourceManager() + { + } + + IGuiGraphicsRenderTarget* GuiRemoteGraphicsResourceManager::GetRenderTarget(INativeWindow* window) + { + CHECK_ERROR(window == &remote->remoteWindow, L"vl::presentation::elements::GuiRemoteGraphicsResourceManager::GetRenderTarget(INativeWindow*)#GuiHostedController should call this function with the native window."); + return &renderTarget; + } + + void GuiRemoteGraphicsResourceManager::RecreateRenderTarget(INativeWindow* window) + { + } + + void GuiRemoteGraphicsResourceManager::ResizeRenderTarget(INativeWindow* window) + { + } + + IGuiGraphicsLayoutProvider* GuiRemoteGraphicsResourceManager::GetLayoutProvider() + { + CHECK_FAIL(L"Not Implemented!"); + } +} + +/*********************************************************************** +.\PLATFORMPROVIDERS\REMOTE\GUIREMOTEPROTOCOLSCHEMASHARED.CPP +***********************************************************************/ + +namespace vl::presentation::remoteprotocol +{ + template<> Ptr ConvertCustomTypeToJson(const bool& value) + { + auto node = Ptr(new glr::json::JsonLiteral); + node->value = value ? glr::json::JsonLiteralValue::True : glr::json::JsonLiteralValue::False; + return node; + } + + template<> Ptr ConvertCustomTypeToJson(const vint& value) + { + auto node = Ptr(new glr::json::JsonNumber); + reflection::description::TypedValueSerializerProvider::Serialize(value, node->content.value); + return node; + } + + template<> Ptr ConvertCustomTypeToJson(const float& value) + { + auto node = Ptr(new glr::json::JsonNumber); + reflection::description::TypedValueSerializerProvider::Serialize(value, node->content.value); + return node; + } + + template<> Ptr ConvertCustomTypeToJson(const double& value) + { + auto node = Ptr(new glr::json::JsonNumber); + reflection::description::TypedValueSerializerProvider::Serialize(value, node->content.value); + return node; + } + + template<> Ptr ConvertCustomTypeToJson(const WString& value) + { + auto node = Ptr(new glr::json::JsonString); + node->content.value = value; + return node; + } + + template<> Ptr ConvertCustomTypeToJson(const wchar_t& value) + { + return ConvertCustomTypeToJson(WString::FromChar(value)); + } + + template<> Ptr ConvertCustomTypeToJson(const VKEY& value) + { + return ConvertCustomTypeToJson((vint)value); + } + + template<> void ConvertJsonToCustomType(Ptr node, bool& value) + { +#define ERROR_MESSAGE_PREFIX L"presentation::remoteprotocol::ConvertJsonToCustomType(Ptr, bool&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"JSON node does not match the expected type."); + switch (jsonNode->value) + { + case glr::json::JsonLiteralValue::True: value = true; break; + case glr::json::JsonLiteralValue::False: value = false; break; + default: CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported json literal."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType(Ptr node, vint& value) + { +#define ERROR_MESSAGE_PREFIX L"presentation::remoteprotocol::ConvertJsonToCustomType(Ptr, vint&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"JSON node does not match the expected type."); + CHECK_ERROR(reflection::description::TypedValueSerializerProvider::Deserialize(jsonNode->content.value, value), ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType(Ptr node, float& value) + { +#define ERROR_MESSAGE_PREFIX L"presentation::remoteprotocol::ConvertJsonToCustomType(Ptr, float&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"JSON node does not match the expected type."); + CHECK_ERROR(reflection::description::TypedValueSerializerProvider::Deserialize(jsonNode->content.value, value), ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType(Ptr node, double& value) + { +#define ERROR_MESSAGE_PREFIX L"presentation::remoteprotocol::ConvertJsonToCustomType(Ptr, double&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"JSON node does not match the expected type."); + CHECK_ERROR(reflection::description::TypedValueSerializerProvider::Deserialize(jsonNode->content.value, value), ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType(Ptr node, WString& value) + { +#define ERROR_MESSAGE_PREFIX L"presentation::remoteprotocol::ConvertJsonToCustomType(Ptr, WString&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"JSON node does not match the expected type."); + value = jsonNode->content.value; +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType(Ptr node, wchar_t& value) + { +#define ERROR_MESSAGE_PREFIX L"presentation::remoteprotocol::ConvertJsonToCustomType(Ptr, wchar_t&)#" + WString strValue; + ConvertJsonToCustomType(node, strValue); + CHECK_ERROR(strValue.Length() == 1, ERROR_MESSAGE_PREFIX L"Char in JSON should be a string with one char."); + value = strValue[0]; +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType(Ptr node, VKEY& value) + { + vint intValue; + ConvertJsonToCustomType(node, intValue); + value = (VKEY)intValue; + } +} + + +/*********************************************************************** +.\PLATFORMPROVIDERS\REMOTE\GUIREMOTEWINDOW.CPP +***********************************************************************/ + +namespace vl::presentation +{ +/*********************************************************************** +GuiRemoteWindow +***********************************************************************/ + +#define SET_REMOTE_WINDOW_STYLE(STYLE, VALUE)\ + if (style ## STYLE != VALUE)\ + {\ + style ## STYLE = VALUE;\ + remoteMessages.RequestWindowNotifySet ## STYLE(VALUE);\ + }\ + +#define SET_REMOTE_WINDOW_STYLE_INVALIDATE(STYLE, VALUE)\ + if (style ## STYLE != VALUE)\ + {\ + style ## STYLE = VALUE;\ + sizingConfigInvalidated = true;\ + remoteMessages.RequestWindowNotifySet ## STYLE(VALUE);\ + }\ + + void GuiRemoteWindow::RequestGetBounds() + { + sizingConfigInvalidated = false; + vint idGetBounds = remoteMessages.RequestWindowGetBounds(); + remoteMessages.Submit(); + OnWindowBoundsUpdated(remoteMessages.RetrieveWindowGetBounds(idGetBounds)); + remoteMessages.ClearResponses(); + } + + void GuiRemoteWindow::Opened() + { + if (!statusVisible) + { + statusVisible = true; + for (auto l : listeners)l->Opened(); + } + } + + void GuiRemoteWindow::SetActivated(bool activated) + { + if (statusActivated != activated) + { + statusActivated = activated; + if (statusActivated) + { + for (auto l : listeners)l->GotFocus(); + for (auto l : listeners)l->RenderingAsActivated(); + } + else + { + for (auto l : listeners)l->LostFocus(); + for (auto l : listeners)l->RenderingAsDeactivated(); + } + } + } + + void GuiRemoteWindow::ShowWithSizeState(bool activate, INativeWindow::WindowSizeState sizeState) + { + if (!statusVisible || remoteWindowSizingConfig.sizeState != sizeState) + { + remoteprotocol::WindowShowing windowShowing; + windowShowing.activate = activate; + windowShowing.sizeState = sizeState; + remoteMessages.RequestWindowNotifyShow(windowShowing); + remoteMessages.Submit(); + + remoteWindowSizingConfig.sizeState = sizeState; + Opened(); + SetActivated(activate); + } + else if (!statusActivated && activate) + { + SetActivate(); + } + } + +/*********************************************************************** +GuiRemoteWindow (events) +***********************************************************************/ + + void GuiRemoteWindow::OnControllerConnect() + { + if (disconnected) + { + disconnected = false; + } + + sizingConfigInvalidated = true; + RequestGetBounds(); + + if (remote->applicationRunning) + { + remoteMessages.RequestWindowNotifySetTitle(styleTitle); + remoteMessages.RequestWindowNotifySetEnabled(styleEnabled); + remoteMessages.RequestWindowNotifySetTopMost(styleTopMost); + remoteMessages.RequestWindowNotifySetShowInTaskBar(styleShowInTaskBar); + remoteMessages.RequestWindowNotifySetCustomFrameMode(styleCustomFrameMode); + remoteMessages.RequestWindowNotifySetMaximizedBox(styleMaximizedBox); + remoteMessages.RequestWindowNotifySetMinimizedBox(styleMinimizedBox); + remoteMessages.RequestWindowNotifySetBorder(styleBorder); + remoteMessages.RequestWindowNotifySetSizeBox(styleSizeBox); + remoteMessages.RequestWindowNotifySetIconVisible(styleIconVisible); + remoteMessages.RequestWindowNotifySetTitleBar(styleTitleBar); + if (statusCapturing) + { + remoteMessages.RequestIORequireCapture(); + } + else + { + remoteMessages.RequestIOReleaseCapture(); + } + remoteMessages.Submit(); + } + } + + void GuiRemoteWindow::OnControllerDisconnect() + { + disconnected = true; + } + + void GuiRemoteWindow::OnControllerScreenUpdated(const remoteprotocol::ScreenConfig& arguments) + { + if (scalingX != arguments.scalingX || scalingY != arguments.scalingY) + { + scalingX = arguments.scalingX; + scalingY = arguments.scalingY; + for (auto l : listeners) l->DpiChanged(true); + for (auto l : listeners) l->DpiChanged(false); + } + } + + void GuiRemoteWindow::OnWindowBoundsUpdated(const remoteprotocol::WindowSizingConfig& arguments) + { + bool callMoved = false; + if (remoteWindowSizingConfig.bounds != arguments.bounds || + remoteWindowSizingConfig.clientBounds != arguments.clientBounds) + { + callMoved = true; + } + + remoteWindowSizingConfig = arguments; + if(callMoved) + { + for (auto l : listeners) l->Moved(); + } + } + + void GuiRemoteWindow::OnWindowActivatedUpdated(bool activated) + { + SetActivated(activated); + } + +/*********************************************************************** +GuiRemoteWindow +***********************************************************************/ + + GuiRemoteWindow::GuiRemoteWindow(GuiRemoteController* _remote) + : remote(_remote) + , remoteMessages(_remote->remoteMessages) + , remoteEvents(_remote->remoteEvents) + { + remoteWindowSizingConfig.sizeState = INativeWindow::Restored; + } + + GuiRemoteWindow::~GuiRemoteWindow() + { + } + +/*********************************************************************** +GuiRemoteWindow (INativeWindow) +***********************************************************************/ + + bool GuiRemoteWindow::IsActivelyRefreshing() + { + return true; + } + + NativeSize GuiRemoteWindow::GetRenderingOffset() + { + return { 0,0 }; + } + + Point GuiRemoteWindow::Convert(NativePoint value) + { + return Point((vint)(value.x.value / scalingX), (vint)(value.y.value / scalingY)); + } + + NativePoint GuiRemoteWindow::Convert(Point value) + { + return NativePoint((vint)(value.x * scalingX), (vint)(value.y * scalingY)); + } + + Size GuiRemoteWindow::Convert(NativeSize value) + { + return Size((vint)(value.x.value / scalingX), (vint)(value.y.value / scalingY)); + } + + NativeSize GuiRemoteWindow::Convert(Size value) + { + return NativeSize((vint)(value.x * scalingX), (vint)(value.y * scalingY)); + } + + Margin GuiRemoteWindow::Convert(NativeMargin value) + { + return Margin( + (vint)(value.left.value / scalingX), + (vint)(value.top.value / scalingY), + (vint)(value.right.value / scalingX), + (vint)(value.bottom.value / scalingY) + ); + } + + NativeMargin GuiRemoteWindow::Convert(Margin value) + { + return NativeMargin( + (vint)(value.left * scalingX), + (vint)(value.top * scalingY), + (vint)(value.right * scalingX), + (vint)(value.bottom * scalingY) + ); + } + + NativeRect GuiRemoteWindow::GetBounds() + { + if (sizingConfigInvalidated) RequestGetBounds(); + return remoteWindowSizingConfig.bounds; + } + + void GuiRemoteWindow::SetBounds(const NativeRect& bounds) + { + if (remoteWindowSizingConfig.bounds != bounds) + { + remoteMessages.RequestWindowNotifySetBounds(bounds); + sizingConfigInvalidated = true; + } + } + + NativeSize GuiRemoteWindow::GetClientSize() + { + if (sizingConfigInvalidated) RequestGetBounds(); + return remoteWindowSizingConfig.clientBounds.GetSize(); + } + + void GuiRemoteWindow::SetClientSize(NativeSize size) + { + if (remoteWindowSizingConfig.clientBounds.GetSize() != size) + { + remoteMessages.RequestWindowNotifySetClientSize(size); + sizingConfigInvalidated = true; + } + } + + NativeRect GuiRemoteWindow::GetClientBoundsInScreen() + { + auto bounds = remoteWindowSizingConfig.clientBounds; + bounds.x1.value += remoteWindowSizingConfig.bounds.x1.value; + bounds.y1.value += remoteWindowSizingConfig.bounds.y1.value; + bounds.x2.value += remoteWindowSizingConfig.bounds.x1.value; + bounds.y2.value += remoteWindowSizingConfig.bounds.y1.value; + return bounds; + } + + WString GuiRemoteWindow::GetTitle() + { + return styleTitle; + } + + void GuiRemoteWindow::SetTitle(const WString& title) + { + SET_REMOTE_WINDOW_STYLE(Title, title); + } + + INativeCursor* GuiRemoteWindow::GetWindowCursor() + { + if (!styleCursor) + { + styleCursor = remote->ResourceService()->GetDefaultSystemCursor(); + } + return styleCursor; + } + + void GuiRemoteWindow::SetWindowCursor(INativeCursor* cursor) + { + styleCursor = cursor; + } + + NativePoint GuiRemoteWindow::GetCaretPoint() + { + return styleCaret; + } + + void GuiRemoteWindow::SetCaretPoint(NativePoint point) + { + styleCaret = point; + } + + INativeWindow* GuiRemoteWindow::GetParent() + { + return nullptr; + } + + void GuiRemoteWindow::SetParent(INativeWindow* parent) + { + CHECK_FAIL(L"vl::presentation::GuiRemoteWindow::SetParent(INativeWindow*)#GuiHostedController is not supposed to call this."); + } + + INativeWindow::WindowMode GuiRemoteWindow::GetWindowMode() + { + return windowMode; + } + + void GuiRemoteWindow::EnableCustomFrameMode() + { + SET_REMOTE_WINDOW_STYLE_INVALIDATE(CustomFrameMode, true); + } + + void GuiRemoteWindow::DisableCustomFrameMode() + { + SET_REMOTE_WINDOW_STYLE_INVALIDATE(CustomFrameMode, false); + } + + bool GuiRemoteWindow::IsCustomFrameModeEnabled() + { + return styleCustomFrameMode; + } + + NativeMargin GuiRemoteWindow::GetCustomFramePadding() + { + return remoteWindowSizingConfig.customFramePadding; + } + + Ptr GuiRemoteWindow::GetIcon() + { + return styleIcon; + } + + void GuiRemoteWindow::SetIcon(Ptr icon) + { + styleIcon = icon; + } + + INativeWindow::WindowSizeState GuiRemoteWindow::GetSizeState() + { + return remoteWindowSizingConfig.sizeState; + } + + void GuiRemoteWindow::Show() + { + ShowWithSizeState(true, remoteWindowSizingConfig.sizeState); + } + + void GuiRemoteWindow::ShowDeactivated() + { + ShowWithSizeState(false, remoteWindowSizingConfig.sizeState); + } + + void GuiRemoteWindow::ShowRestored() + { + ShowWithSizeState(true, INativeWindow::Restored); + } + + void GuiRemoteWindow::ShowMaximized() + { + ShowWithSizeState(true, INativeWindow::Maximized); + } + + void GuiRemoteWindow::ShowMinimized() + { + ShowWithSizeState(true, INativeWindow::Minimized); + } + + void GuiRemoteWindow::Hide(bool closeWindow) + { + if (!remote->connectionForcedToStop) + { + bool cancel = false; + for (auto l : listeners) + { + l->BeforeClosing(cancel); + if (cancel) return; + } + for (auto l : listeners) l->AfterClosing(); + } + remote->DestroyNativeWindow(this); + } + + bool GuiRemoteWindow::IsVisible() + { + return statusVisible; + } + + void GuiRemoteWindow::Enable() + { + if (styleEnabled != true) + { + styleEnabled = true; + remoteMessages.RequestWindowNotifySetEnabled(true); + for (auto l : listeners) l->Enabled(); + } + } + + void GuiRemoteWindow::Disable() + { + if (styleEnabled != false) + { + styleEnabled = false; + remoteMessages.RequestWindowNotifySetEnabled(false); + for (auto l : listeners) l->Disabled(); + } + } + + bool GuiRemoteWindow::IsEnabled() + { + return styleEnabled; + } + + void GuiRemoteWindow::SetActivate() + { + if (statusActivated != true) + { + SetActivated(true); + remoteMessages.RequestWindowNotifyActivate(); + } + } + + bool GuiRemoteWindow::IsActivated() + { + return statusActivated; + } + + bool GuiRemoteWindow::IsRenderingAsActivated() + { + return statusActivated; + } + + void GuiRemoteWindow::ShowInTaskBar() + { + SET_REMOTE_WINDOW_STYLE(ShowInTaskBar, true); + } + + void GuiRemoteWindow::HideInTaskBar() + { + SET_REMOTE_WINDOW_STYLE(ShowInTaskBar, false); + } + + bool GuiRemoteWindow::IsAppearedInTaskBar() + { + return styleShowInTaskBar; + } + + void GuiRemoteWindow::EnableActivate() + { + CHECK_FAIL(L"vl::presentation::GuiRemoteWindow::EnableActivate()#GuiHostedController is not supposed to call this."); + } + + void GuiRemoteWindow::DisableActivate() + { + CHECK_FAIL(L"vl::presentation::GuiRemoteWindow::EnableActivate()#GuiHostedController is not supposed to call this."); + } + + bool GuiRemoteWindow::IsEnabledActivate() + { + return true; + } + + bool GuiRemoteWindow::RequireCapture() + { + if (!statusCapturing) + { + statusCapturing = true; + remoteMessages.RequestIORequireCapture(); + remoteMessages.Submit(); + } + return true; + } + + bool GuiRemoteWindow::ReleaseCapture() + { + if (statusCapturing) + { + statusCapturing = false; + remoteMessages.RequestIOReleaseCapture(); + remoteMessages.Submit(); + } + return true; + } + + bool GuiRemoteWindow::IsCapturing() + { + return statusCapturing; + } + + bool GuiRemoteWindow::GetMaximizedBox() + { + return styleMaximizedBox; + } + + void GuiRemoteWindow::SetMaximizedBox(bool visible) + { + SET_REMOTE_WINDOW_STYLE_INVALIDATE(MaximizedBox, visible); + } + + bool GuiRemoteWindow::GetMinimizedBox() + { + return styleMinimizedBox; + } + + void GuiRemoteWindow::SetMinimizedBox(bool visible) + { + SET_REMOTE_WINDOW_STYLE_INVALIDATE(MinimizedBox, visible); + } + + bool GuiRemoteWindow::GetBorder() + { + return styleBorder; + } + + void GuiRemoteWindow::SetBorder(bool visible) + { + SET_REMOTE_WINDOW_STYLE_INVALIDATE(Border, visible); + } + + bool GuiRemoteWindow::GetSizeBox() + { + return styleSizeBox; + } + + void GuiRemoteWindow::SetSizeBox(bool visible) + { + SET_REMOTE_WINDOW_STYLE_INVALIDATE(SizeBox, visible); + } + + bool GuiRemoteWindow::GetIconVisible() + { + return styleIconVisible; + } + + void GuiRemoteWindow::SetIconVisible(bool visible) + { + SET_REMOTE_WINDOW_STYLE_INVALIDATE(IconVisible, visible); + } + + bool GuiRemoteWindow::GetTitleBar() + { + return styleTitleBar; + } + + void GuiRemoteWindow::SetTitleBar(bool visible) + { + SET_REMOTE_WINDOW_STYLE_INVALIDATE(TitleBar, visible); + } + + bool GuiRemoteWindow::GetTopMost() + { + return styleTopMost; + } + + void GuiRemoteWindow::SetTopMost(bool topmost) + { + SET_REMOTE_WINDOW_STYLE(TopMost, topmost); + } + + void GuiRemoteWindow::SupressAlt() + { + } + + bool GuiRemoteWindow::InstallListener(INativeWindowListener* listener) + { + if (listeners.Contains(listener)) + { + return false; + } + else + { + listeners.Add(listener); + return true; + } + } + + bool GuiRemoteWindow::UninstallListener(INativeWindowListener* listener) + { + if (listeners.Contains(listener)) + { + listeners.Remove(listener); + return true; + } + else + { + return false; + } + } + + void GuiRemoteWindow::RedrawContent() + { + CHECK_FAIL(L"Not Implemented!"); + } + +#undef SET_REMOTE_WINDOW_STYLE_INVALIDATE +#undef SET_REMOTE_WINDOW_STYLE +} + +/*********************************************************************** +.\PLATFORMPROVIDERS\REMOTE\PROTOCOL\GENERATED\GUIREMOTEPROTOCOLSCHEMA.CPP +***********************************************************************/ +/*********************************************************************** +This file is generated by : Vczh GacUI Remote Protocol Generator +Licensed under https ://github.com/vczh-libraries/License +***********************************************************************/ + + +namespace vl::presentation::remoteprotocol +{ + template<> vl::Ptr ConvertCustomTypeToJson(const vl::presentation::remoteprotocol::IOMouseButton & value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertCustomTypeToJson(const vl::presentation::remoteprotocol::IOMouseButton&)#" + auto node = Ptr(new glr::json::JsonString); + switch (value) + { + case vl::presentation::remoteprotocol::IOMouseButton::Left: node->content.value = L"Left"; break; + case vl::presentation::remoteprotocol::IOMouseButton::Middle: node->content.value = L"Middle"; break; + case vl::presentation::remoteprotocol::IOMouseButton::Right: node->content.value = L"Right"; break; + default: CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported enum value."); + } + return node; +#undef ERROR_MESSAGE_PREFIX + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::INativeWindow::WindowSizeState>(const ::vl::presentation::INativeWindow::WindowSizeState & value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertCustomTypeToJson<::vl::presentation::INativeWindow::WindowSizeState>(const ::vl::presentation::INativeWindow::WindowSizeState&)#" + auto node = Ptr(new glr::json::JsonString); + switch (value) + { + case ::vl::presentation::INativeWindow::WindowSizeState::Minimized: node->content.value = L"Minimized"; break; + case ::vl::presentation::INativeWindow::WindowSizeState::Restored: node->content.value = L"Restored"; break; + case ::vl::presentation::INativeWindow::WindowSizeState::Maximized: node->content.value = L"Maximized"; break; + default: CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported enum value."); + } + return node; +#undef ERROR_MESSAGE_PREFIX + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativeCoordinate>(const ::vl::presentation::NativeCoordinate & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"value", value.value); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativePoint>(const ::vl::presentation::NativePoint & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"x", value.x); + ConvertCustomTypeToJsonField(node, L"y", value.y); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativeSize>(const ::vl::presentation::NativeSize & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"x", value.x); + ConvertCustomTypeToJsonField(node, L"y", value.y); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativeRect>(const ::vl::presentation::NativeRect & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"x1", value.x1); + ConvertCustomTypeToJsonField(node, L"y1", value.y1); + ConvertCustomTypeToJsonField(node, L"x2", value.x2); + ConvertCustomTypeToJsonField(node, L"y2", value.y2); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativeMargin>(const ::vl::presentation::NativeMargin & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"left", value.left); + ConvertCustomTypeToJsonField(node, L"top", value.top); + ConvertCustomTypeToJsonField(node, L"right", value.right); + ConvertCustomTypeToJsonField(node, L"bottom", value.bottom); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::FontProperties>(const ::vl::presentation::FontProperties & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"fontFamily", value.fontFamily); + ConvertCustomTypeToJsonField(node, L"size", value.size); + ConvertCustomTypeToJsonField(node, L"bold", value.bold); + ConvertCustomTypeToJsonField(node, L"italic", value.italic); + ConvertCustomTypeToJsonField(node, L"underline", value.underline); + ConvertCustomTypeToJsonField(node, L"strikeline", value.strikeline); + ConvertCustomTypeToJsonField(node, L"antialias", value.antialias); + ConvertCustomTypeToJsonField(node, L"verticalAntialias", value.verticalAntialias); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson(const vl::presentation::remoteprotocol::FontConfig & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"defaultFont", value.defaultFont); + ConvertCustomTypeToJsonField(node, L"supportedFonts", value.supportedFonts); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson(const vl::presentation::remoteprotocol::ScreenConfig & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"bounds", value.bounds); + ConvertCustomTypeToJsonField(node, L"clientBounds", value.clientBounds); + ConvertCustomTypeToJsonField(node, L"scalingX", value.scalingX); + ConvertCustomTypeToJsonField(node, L"scalingY", value.scalingY); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativeWindowMouseInfo>(const ::vl::presentation::NativeWindowMouseInfo & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"ctrl", value.ctrl); + ConvertCustomTypeToJsonField(node, L"shift", value.shift); + ConvertCustomTypeToJsonField(node, L"left", value.left); + ConvertCustomTypeToJsonField(node, L"middle", value.middle); + ConvertCustomTypeToJsonField(node, L"right", value.right); + ConvertCustomTypeToJsonField(node, L"x", value.x); + ConvertCustomTypeToJsonField(node, L"y", value.y); + ConvertCustomTypeToJsonField(node, L"wheel", value.wheel); + ConvertCustomTypeToJsonField(node, L"nonClient", value.nonClient); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson(const vl::presentation::remoteprotocol::IOMouseInfoWithButton & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"button", value.button); + ConvertCustomTypeToJsonField(node, L"info", value.info); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativeWindowKeyInfo>(const ::vl::presentation::NativeWindowKeyInfo & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"code", value.code); + ConvertCustomTypeToJsonField(node, L"ctrl", value.ctrl); + ConvertCustomTypeToJsonField(node, L"shift", value.shift); + ConvertCustomTypeToJsonField(node, L"alt", value.alt); + ConvertCustomTypeToJsonField(node, L"capslock", value.capslock); + ConvertCustomTypeToJsonField(node, L"autoRepeatKeyDown", value.autoRepeatKeyDown); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativeWindowCharInfo>(const ::vl::presentation::NativeWindowCharInfo & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"code", value.code); + ConvertCustomTypeToJsonField(node, L"ctrl", value.ctrl); + ConvertCustomTypeToJsonField(node, L"shift", value.shift); + ConvertCustomTypeToJsonField(node, L"alt", value.alt); + ConvertCustomTypeToJsonField(node, L"capslock", value.capslock); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson(const vl::presentation::remoteprotocol::GlobalShortcutKey & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"id", value.id); + ConvertCustomTypeToJsonField(node, L"ctrl", value.ctrl); + ConvertCustomTypeToJsonField(node, L"shift", value.shift); + ConvertCustomTypeToJsonField(node, L"alt", value.alt); + ConvertCustomTypeToJsonField(node, L"code", value.code); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson(const vl::presentation::remoteprotocol::WindowSizingConfig & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"bounds", value.bounds); + ConvertCustomTypeToJsonField(node, L"clientBounds", value.clientBounds); + ConvertCustomTypeToJsonField(node, L"sizeState", value.sizeState); + ConvertCustomTypeToJsonField(node, L"customFramePadding", value.customFramePadding); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson(const vl::presentation::remoteprotocol::WindowShowing & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"activate", value.activate); + ConvertCustomTypeToJsonField(node, L"sizeState", value.sizeState); + return node; + } + + template<> void ConvertJsonToCustomType(vl::Ptr node, vl::presentation::remoteprotocol::IOMouseButton& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType(Ptr, vl::presentation::remoteprotocol::IOMouseButton&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + if (jsonNode->content.value == L"Left") value = vl::presentation::remoteprotocol::IOMouseButton::Left; else + if (jsonNode->content.value == L"Middle") value = vl::presentation::remoteprotocol::IOMouseButton::Middle; else + if (jsonNode->content.value == L"Right") value = vl::presentation::remoteprotocol::IOMouseButton::Right; else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported enum value."); +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::INativeWindow::WindowSizeState>(vl::Ptr node, ::vl::presentation::INativeWindow::WindowSizeState& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::INativeWindow::WindowSizeState>(Ptr, ::vl::presentation::INativeWindow::WindowSizeState&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + if (jsonNode->content.value == L"Minimized") value = ::vl::presentation::INativeWindow::WindowSizeState::Minimized; else + if (jsonNode->content.value == L"Restored") value = ::vl::presentation::INativeWindow::WindowSizeState::Restored; else + if (jsonNode->content.value == L"Maximized") value = ::vl::presentation::INativeWindow::WindowSizeState::Maximized; else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported enum value."); +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::NativeCoordinate>(vl::Ptr node, ::vl::presentation::NativeCoordinate& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::NativeCoordinate>(Ptr, ::vl::presentation::NativeCoordinate&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"value") ConvertJsonToCustomType(field->value, value.value); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::NativePoint>(vl::Ptr node, ::vl::presentation::NativePoint& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::NativePoint>(Ptr, ::vl::presentation::NativePoint&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"x") ConvertJsonToCustomType(field->value, value.x); else + if (field->name.value == L"y") ConvertJsonToCustomType(field->value, value.y); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::NativeSize>(vl::Ptr node, ::vl::presentation::NativeSize& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::NativeSize>(Ptr, ::vl::presentation::NativeSize&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"x") ConvertJsonToCustomType(field->value, value.x); else + if (field->name.value == L"y") ConvertJsonToCustomType(field->value, value.y); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::NativeRect>(vl::Ptr node, ::vl::presentation::NativeRect& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::NativeRect>(Ptr, ::vl::presentation::NativeRect&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"x1") ConvertJsonToCustomType(field->value, value.x1); else + if (field->name.value == L"y1") ConvertJsonToCustomType(field->value, value.y1); else + if (field->name.value == L"x2") ConvertJsonToCustomType(field->value, value.x2); else + if (field->name.value == L"y2") ConvertJsonToCustomType(field->value, value.y2); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::NativeMargin>(vl::Ptr node, ::vl::presentation::NativeMargin& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::NativeMargin>(Ptr, ::vl::presentation::NativeMargin&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"left") ConvertJsonToCustomType(field->value, value.left); else + if (field->name.value == L"top") ConvertJsonToCustomType(field->value, value.top); else + if (field->name.value == L"right") ConvertJsonToCustomType(field->value, value.right); else + if (field->name.value == L"bottom") ConvertJsonToCustomType(field->value, value.bottom); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::FontProperties>(vl::Ptr node, ::vl::presentation::FontProperties& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::FontProperties>(Ptr, ::vl::presentation::FontProperties&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"fontFamily") ConvertJsonToCustomType(field->value, value.fontFamily); else + if (field->name.value == L"size") ConvertJsonToCustomType(field->value, value.size); else + if (field->name.value == L"bold") ConvertJsonToCustomType(field->value, value.bold); else + if (field->name.value == L"italic") ConvertJsonToCustomType(field->value, value.italic); else + if (field->name.value == L"underline") ConvertJsonToCustomType(field->value, value.underline); else + if (field->name.value == L"strikeline") ConvertJsonToCustomType(field->value, value.strikeline); else + if (field->name.value == L"antialias") ConvertJsonToCustomType(field->value, value.antialias); else + if (field->name.value == L"verticalAntialias") ConvertJsonToCustomType(field->value, value.verticalAntialias); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType(vl::Ptr node, vl::presentation::remoteprotocol::FontConfig& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType(Ptr, vl::presentation::remoteprotocol::FontConfig&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"defaultFont") ConvertJsonToCustomType(field->value, value.defaultFont); else + if (field->name.value == L"supportedFonts") ConvertJsonToCustomType(field->value, value.supportedFonts); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType(vl::Ptr node, vl::presentation::remoteprotocol::ScreenConfig& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType(Ptr, vl::presentation::remoteprotocol::ScreenConfig&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"bounds") ConvertJsonToCustomType(field->value, value.bounds); else + if (field->name.value == L"clientBounds") ConvertJsonToCustomType(field->value, value.clientBounds); else + if (field->name.value == L"scalingX") ConvertJsonToCustomType(field->value, value.scalingX); else + if (field->name.value == L"scalingY") ConvertJsonToCustomType(field->value, value.scalingY); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::NativeWindowMouseInfo>(vl::Ptr node, ::vl::presentation::NativeWindowMouseInfo& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::NativeWindowMouseInfo>(Ptr, ::vl::presentation::NativeWindowMouseInfo&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"ctrl") ConvertJsonToCustomType(field->value, value.ctrl); else + if (field->name.value == L"shift") ConvertJsonToCustomType(field->value, value.shift); else + if (field->name.value == L"left") ConvertJsonToCustomType(field->value, value.left); else + if (field->name.value == L"middle") ConvertJsonToCustomType(field->value, value.middle); else + if (field->name.value == L"right") ConvertJsonToCustomType(field->value, value.right); else + if (field->name.value == L"x") ConvertJsonToCustomType(field->value, value.x); else + if (field->name.value == L"y") ConvertJsonToCustomType(field->value, value.y); else + if (field->name.value == L"wheel") ConvertJsonToCustomType(field->value, value.wheel); else + if (field->name.value == L"nonClient") ConvertJsonToCustomType(field->value, value.nonClient); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType(vl::Ptr node, vl::presentation::remoteprotocol::IOMouseInfoWithButton& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType(Ptr, vl::presentation::remoteprotocol::IOMouseInfoWithButton&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"button") ConvertJsonToCustomType(field->value, value.button); else + if (field->name.value == L"info") ConvertJsonToCustomType(field->value, value.info); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::NativeWindowKeyInfo>(vl::Ptr node, ::vl::presentation::NativeWindowKeyInfo& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::NativeWindowKeyInfo>(Ptr, ::vl::presentation::NativeWindowKeyInfo&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"code") ConvertJsonToCustomType(field->value, value.code); else + if (field->name.value == L"ctrl") ConvertJsonToCustomType(field->value, value.ctrl); else + if (field->name.value == L"shift") ConvertJsonToCustomType(field->value, value.shift); else + if (field->name.value == L"alt") ConvertJsonToCustomType(field->value, value.alt); else + if (field->name.value == L"capslock") ConvertJsonToCustomType(field->value, value.capslock); else + if (field->name.value == L"autoRepeatKeyDown") ConvertJsonToCustomType(field->value, value.autoRepeatKeyDown); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::NativeWindowCharInfo>(vl::Ptr node, ::vl::presentation::NativeWindowCharInfo& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::NativeWindowCharInfo>(Ptr, ::vl::presentation::NativeWindowCharInfo&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"code") ConvertJsonToCustomType(field->value, value.code); else + if (field->name.value == L"ctrl") ConvertJsonToCustomType(field->value, value.ctrl); else + if (field->name.value == L"shift") ConvertJsonToCustomType(field->value, value.shift); else + if (field->name.value == L"alt") ConvertJsonToCustomType(field->value, value.alt); else + if (field->name.value == L"capslock") ConvertJsonToCustomType(field->value, value.capslock); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType(vl::Ptr node, vl::presentation::remoteprotocol::GlobalShortcutKey& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType(Ptr, vl::presentation::remoteprotocol::GlobalShortcutKey&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"id") ConvertJsonToCustomType(field->value, value.id); else + if (field->name.value == L"ctrl") ConvertJsonToCustomType(field->value, value.ctrl); else + if (field->name.value == L"shift") ConvertJsonToCustomType(field->value, value.shift); else + if (field->name.value == L"alt") ConvertJsonToCustomType(field->value, value.alt); else + if (field->name.value == L"code") ConvertJsonToCustomType(field->value, value.code); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType(vl::Ptr node, vl::presentation::remoteprotocol::WindowSizingConfig& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType(Ptr, vl::presentation::remoteprotocol::WindowSizingConfig&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"bounds") ConvertJsonToCustomType(field->value, value.bounds); else + if (field->name.value == L"clientBounds") ConvertJsonToCustomType(field->value, value.clientBounds); else + if (field->name.value == L"sizeState") ConvertJsonToCustomType(field->value, value.sizeState); else + if (field->name.value == L"customFramePadding") ConvertJsonToCustomType(field->value, value.customFramePadding); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType(vl::Ptr node, vl::presentation::remoteprotocol::WindowShowing& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType(Ptr, vl::presentation::remoteprotocol::WindowShowing&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"activate") ConvertJsonToCustomType(field->value, value.activate); else + if (field->name.value == L"sizeState") ConvertJsonToCustomType(field->value, value.sizeState); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + +} + + /*********************************************************************** .\RESOURCES\GUIDOCUMENT.CPP ***********************************************************************/ diff --git a/Import/GacUI.h b/Import/GacUI.h index fe2b6676..ae8d3d9e 100644 --- a/Import/GacUI.h +++ b/Import/GacUI.h @@ -648,7 +648,7 @@ Resources Keys ***********************************************************************/ -#define GUI_DEFINE_KEYBOARD_CODE(ITEM) \ +#define GUI_DEFINE_KEYBOARD_CODE_BASIC(ITEM) \ /* \ * Virtual Keys, Standard Set \ */ \ @@ -670,7 +670,6 @@ ITEM(CAPITAL, 0x14) \ ITEM(KANA_HANGUL, 0x15) \ ITEM(JUNJA, 0x17) \ ITEM(FINAL, 0x18) \ -ITEM(HANJA, 0x19) \ ITEM(KANJI, 0x19) \ ITEM(ESCAPE, 0x1B) \ ITEM(CONVERT, 0x1C) \ @@ -779,10 +778,6 @@ ITEM(F23, 0x86) \ ITEM(F24, 0x87) \ ITEM(NUMLOCK, 0x90) \ ITEM(SCROLL, 0x91) \ -/* \ - * NEC PC-9800 kbd definitions \ - */ \ -ITEM(OEM_NEC_EQUAL, 0x92) /* '=' key on numpad */ \ /* \ * Fujitsu/OASYS kbd definitions \ */ \ @@ -820,17 +815,10 @@ ITEM(LAUNCH_MAIL, 0xB4) \ ITEM(LAUNCH_MEDIA_SELECT, 0xB5) \ ITEM(LAUNCH_APP1, 0xB6) \ ITEM(LAUNCH_APP2, 0xB7) \ -ITEM(OEM_1, 0xBA) /* ';:' for US */ \ ITEM(OEM_PLUS, 0xBB) /* '+' any country */ \ ITEM(OEM_COMMA, 0xBC) /* ',' any country */ \ ITEM(OEM_MINUS, 0xBD) /* '-' any country */ \ ITEM(OEM_PERIOD, 0xBE) /* '.' any country */ \ -ITEM(OEM_2, 0xBF) /* '/?' for US */ \ -ITEM(OEM_3, 0xC0) /* '`~' for US */ \ -ITEM(OEM_4, 0xDB) /* '[{' for US */ \ -ITEM(OEM_5, 0xDC) /* '\|' for US */ \ -ITEM(OEM_6, 0xDD) /* ']}' for US */ \ -ITEM(OEM_7, 0xDE) /* ''"' for US */ \ ITEM(OEM_8, 0xDF) \ /* \ * Various extended or enhanced keyboards \ @@ -878,19 +866,142 @@ ITEM(BACKSLASH, 0xDC) /* OEM_5 */ \ ITEM(LEFT_BRACKET, 0xDD) /* OEM_6 */ \ ITEM(APOSTROPHE, 0xDE) /* OEM_7 */ \ +#define GUI_DEFINE_KEYBOARD_CODE_ADDITIONAL(ITEM) \ +ITEM(OEM_1, 0xBA) /* ';:' for US */ \ +ITEM(OEM_2, 0xBF) /* '/?' for US */ \ +ITEM(OEM_3, 0xC0) /* '`~' for US */ \ +ITEM(OEM_4, 0xDB) /* '[{' for US */ \ +ITEM(OEM_5, 0xDC) /* '\|' for US */ \ +ITEM(OEM_6, 0xDD) /* ']}' for US */ \ +ITEM(OEM_7, 0xDE) /* ''"' for US */ \ +ITEM(HANJA, 0x19) \ +/* \ + * NEC PC-9800 kbd definitions \ + */ \ +ITEM(OEM_NEC_EQUAL, 0x92) /* '=' key on numpad */ \ + +#define GUI_DEFINE_KEYBOARD_CODE(ITEM) \ + GUI_DEFINE_KEYBOARD_CODE_BASIC(ITEM) \ + GUI_DEFINE_KEYBOARD_CODE_ADDITIONAL(ITEM) \ + + +#define GUI_DEFINE_KEYBOARD_WINDOWS_NAME(ITEM) \ +ITEM(BACK, L"Backspace")\ +ITEM(TAB, L"Tab")\ +ITEM(RETURN, L"Enter")\ +ITEM(SHIFT, L"Shift")\ +ITEM(CONTROL, L"Ctrl")\ +ITEM(MENU, L"Alt")\ +ITEM(CAPITAL, L"Caps Lock")\ +ITEM(ESCAPE, L"Esc")\ +ITEM(SPACE, L"Space")\ +ITEM(PRIOR, L"Page Up")\ +ITEM(NEXT, L"Page Down")\ +ITEM(END, L"End")\ +ITEM(HOME, L"Home")\ +ITEM(LEFT, L"Left")\ +ITEM(UP, L"Up")\ +ITEM(RIGHT, L"Right")\ +ITEM(DOWN, L"Down")\ +ITEM(SNAPSHOT, L"Sys Req")\ +ITEM(INSERT, L"Insert")\ +ITEM(DELETE, L"Delete")\ +ITEM(0, L"0")\ +ITEM(1, L"1")\ +ITEM(2, L"2")\ +ITEM(3, L"3")\ +ITEM(4, L"4")\ +ITEM(5, L"5")\ +ITEM(6, L"6")\ +ITEM(7, L"7")\ +ITEM(8, L"8")\ +ITEM(9, L"9")\ +ITEM(A, L"A")\ +ITEM(B, L"B")\ +ITEM(C, L"C")\ +ITEM(D, L"D")\ +ITEM(E, L"E")\ +ITEM(F, L"F")\ +ITEM(G, L"G")\ +ITEM(H, L"H")\ +ITEM(I, L"I")\ +ITEM(J, L"J")\ +ITEM(K, L"K")\ +ITEM(L, L"L")\ +ITEM(M, L"M")\ +ITEM(N, L"N")\ +ITEM(O, L"O")\ +ITEM(P, L"P")\ +ITEM(Q, L"Q")\ +ITEM(R, L"R")\ +ITEM(S, L"S")\ +ITEM(T, L"T")\ +ITEM(U, L"U")\ +ITEM(V, L"V")\ +ITEM(W, L"W")\ +ITEM(X, L"X")\ +ITEM(Y, L"Y")\ +ITEM(Z, L"Z")\ +ITEM(NUMPAD0, L"Num 0")\ +ITEM(NUMPAD1, L"Num 1")\ +ITEM(NUMPAD2, L"Num 2")\ +ITEM(NUMPAD3, L"Num 3")\ +ITEM(NUMPAD4, L"Num 4")\ +ITEM(NUMPAD5, L"Num 5")\ +ITEM(NUMPAD6, L"Num 6")\ +ITEM(NUMPAD7, L"Num 7")\ +ITEM(NUMPAD8, L"Num 8")\ +ITEM(NUMPAD9, L"Num 9")\ +ITEM(MULTIPLY, L"Num *")\ +ITEM(ADD, L"Num +")\ +ITEM(SUBTRACT, L"Num -")\ +ITEM(DECIMAL, L"Num Del")\ +ITEM(DIVIDE, L"/")\ +ITEM(F1, L"F1")\ +ITEM(F2, L"F2")\ +ITEM(F3, L"F3")\ +ITEM(F4, L"F4")\ +ITEM(F5, L"F5")\ +ITEM(F6, L"F6")\ +ITEM(F7, L"F7")\ +ITEM(F8, L"F8")\ +ITEM(F9, L"F9")\ +ITEM(F10, L"F10")\ +ITEM(F11, L"F11")\ +ITEM(F12, L"F12")\ +ITEM(NUMLOCK, L"Pause")\ +ITEM(SCROLL, L"Scroll Lock")\ +ITEM(BROWSER_HOME, L"M")\ +ITEM(VOLUME_MUTE, L"D")\ +ITEM(VOLUME_DOWN, L"C")\ +ITEM(VOLUME_UP, L"B")\ +ITEM(MEDIA_NEXT_TRACK, L"P")\ +ITEM(MEDIA_PREV_TRACK, L"Q")\ +ITEM(MEDIA_STOP, L"J")\ +ITEM(MEDIA_PLAY_PAUSE, L"G")\ +ITEM(LAUNCH_APP2, L"F")\ +ITEM(OEM_PLUS, L"=")\ +ITEM(OEM_COMMA, L",")\ +ITEM(OEM_MINUS, L"-")\ +ITEM(OEM_PERIOD, L".")\ +ITEM(OEM_102, L"\\")\ +ITEM(SEMICOLON, L";")\ +ITEM(SLASH, L"/")\ +ITEM(GRAVE_ACCENT, L"`")\ +ITEM(RIGHT_BRACKET, L"[")\ +ITEM(BACKSLASH, L"\\")\ +ITEM(LEFT_BRACKET, L"]")\ +ITEM(APOSTROPHE, L"'")\ + #define GUI_DEFINE_KEYBOARD_CODE_ENUM_ITEM(NAME, CODE) KEY_##NAME = CODE, enum class VKEY { KEY_UNKNOWN = -1, + KEY_MAXIMUM = 255, GUI_DEFINE_KEYBOARD_CODE(GUI_DEFINE_KEYBOARD_CODE_ENUM_ITEM) }; #undef GUI_DEFINE_KEYBOARD_CODE_ENUM_ITEM - static bool operator == (VKEY a, VKEY b) { return (vint)a == (vint)b; } - static bool operator != (VKEY a, VKEY b) { return (vint)a != (vint)b; } - static bool operator < (VKEY a, VKEY b) { return (vint)a < (vint)b; } - static bool operator <= (VKEY a, VKEY b) { return (vint)a <= (vint)b; } - static bool operator > (VKEY a, VKEY b) { return (vint)a > (vint)b; } - static bool operator >= (VKEY a, VKEY b) { return (vint)a >= (vint)b; } + static auto operator <=> (VKEY a, VKEY b) { return (vint)a <=> (vint)b; } static VKEY operator & (VKEY a, VKEY b) { return (VKEY)((vint)a & (vint)b); } static VKEY operator | (VKEY a, VKEY b) { return (VKEY)((vint)a | (vint)b); } @@ -6987,8 +7098,8 @@ GacUI::Hosted Window ***********************************************************************/ -#ifndef VCZH_PRESENTATION_GUIHOSTEDGRAPHICS -#define VCZH_PRESENTATION_GUIHOSTEDGRAPHICS +#ifndef VCZH_PRESENTATION_GUIHOSTEDCONTROLLER_GUIHOSTEDGRAPHICS +#define VCZH_PRESENTATION_GUIHOSTEDCONTROLLER_GUIHOSTEDGRAPHICS namespace vl @@ -7043,8 +7154,8 @@ GacUI::Hosted Window ***********************************************************************/ -#ifndef VCZH_PRESENTATION_GUIHOSTEDWINDOWMANAGER -#define VCZH_PRESENTATION_GUIHOSTEDWINDOWMANAGER +#ifndef VCZH_PRESENTATION_GUIHOSTEDCONTROLLER_GUIHOSTEDWINDOWMANAGER +#define VCZH_PRESENTATION_GUIHOSTEDCONTROLLER_GUIHOSTEDWINDOWMANAGER namespace vl @@ -7530,13 +7641,13 @@ Window { current = current->parent; } + windowManager->activeWindow = current; + windowManager->needRefresh = true; if (current) { current->active = true; windowManager->OnGotFocus(current); } - windowManager->activeWindow = current; - windowManager->needRefresh = true; } #undef ERROR_MESSAGE_PREFIX } @@ -7703,8 +7814,8 @@ GacUI::Hosted Window ***********************************************************************/ -#ifndef VCZH_PRESENTATION_GUIHOSTEDWINDOW -#define VCZH_PRESENTATION_GUIHOSTEDWINDOW +#ifndef VCZH_PRESENTATION_GUIHOSTEDCONTROLLER_GUIHOSTEDWINDOW +#define VCZH_PRESENTATION_GUIHOSTEDCONTROLLER_GUIHOSTEDWINDOW namespace vl @@ -7786,7 +7897,7 @@ Proxy extern Ptr CreatePlaceholderHostedWindowProxy(GuiHostedWindowData* data); extern Ptr CreateMainHostedWindowProxy(GuiHostedWindowData* data, INativeWindow* nativeWindow); - extern Ptr CreateNonMainHostedWindowProxy(GuiHostedWindowData* data); + extern Ptr CreateNonMainHostedWindowProxy(GuiHostedWindowData* data, INativeWindow* nativeWindow); /*********************************************************************** GuiHostedWindow @@ -7811,7 +7922,7 @@ GuiHostedWindow ~GuiHostedWindow(); // ============================================================= - // INativeWindowListener + // INativeWindow // ============================================================= bool IsActivelyRefreshing() override; @@ -7889,6 +8000,439 @@ GuiHostedWindow #endif +/*********************************************************************** +.\PLATFORMPROVIDERS\REMOTE\GUIREMOTEGRAPHICS.H +***********************************************************************/ +/*********************************************************************** +Vczh Library++ 3.0 +Developer: Zihan Chen(vczh) +GacUI::Remote Window + +Interfaces: + GuiRemoteController + +***********************************************************************/ + +#ifndef VCZH_PRESENTATION_GUIREMOTEGRAPHICS +#define VCZH_PRESENTATION_GUIREMOTEGRAPHICS + + +namespace vl::presentation +{ + class GuiRemoteController; + + namespace elements + { +/*********************************************************************** +GuiRemoteGraphicsRenderTarget +***********************************************************************/ + + class GuiRemoteGraphicsRenderTarget : public GuiGraphicsRenderTarget + { + protected: + GuiRemoteController* remote; + NativeSize canvasSize; + + void StartRenderingOnNativeWindow() override; + RenderTargetFailure StopRenderingOnNativeWindow() override; + + Size GetCanvasSize() override; + void AfterPushedClipper(Rect clipper, Rect validArea) override; + void AfterPushedClipperAndBecameInvalid(Rect clipper) override; + void AfterPoppedClipperAndBecameValid(Rect validArea, bool clipperExists) override; + void AfterPoppedClipper(Rect validArea, bool clipperExists) override; + public: + GuiRemoteGraphicsRenderTarget(GuiRemoteController* _remote); + ~GuiRemoteGraphicsRenderTarget(); + }; + +/*********************************************************************** +GuiRemoteGraphicsResourceManager +***********************************************************************/ + + class GuiRemoteGraphicsResourceManager : public GuiGraphicsResourceManager + { + protected: + GuiRemoteController* remote; + GuiRemoteGraphicsRenderTarget renderTarget; + + public: + GuiRemoteGraphicsResourceManager(GuiRemoteController* _remote); + ~GuiRemoteGraphicsResourceManager(); + + // ============================================================= + // IGuiGraphicsResourceManager + // ============================================================= + + IGuiGraphicsRenderTarget* GetRenderTarget(INativeWindow* window) override; + void RecreateRenderTarget(INativeWindow* window) override; + void ResizeRenderTarget(INativeWindow* window) override; + IGuiGraphicsLayoutProvider* GetLayoutProvider() override; + }; + } +} + +#endif + +/*********************************************************************** +.\PLATFORMPROVIDERS\REMOTE\GUIREMOTEPROTOCOLSCHEMASHARED.H +***********************************************************************/ +/*********************************************************************** +Vczh Library++ 3.0 +Developer: Zihan Chen(vczh) +GacUI::Remote Window + +Interfaces: + IGuiRemoteProtocol + +***********************************************************************/ + +#ifndef VCZH_PRESENTATION_GUIREMOTECONTROLLER_REMOTEPROTOCOLSCHEMASHARED +#define VCZH_PRESENTATION_GUIREMOTECONTROLLER_REMOTEPROTOCOLSCHEMASHARED + + +namespace vl::presentation::remoteprotocol +{ + template + struct JsonHelper + { + static Ptr ToJson(const T& value); + static void ConvertJsonToCustomType(Ptr node, T& value); + }; + + template + Ptr ConvertCustomTypeToJson(const T& value) + { + return JsonHelper::ToJson(value); + } + + template<> Ptr ConvertCustomTypeToJson(const bool& value); + template<> Ptr ConvertCustomTypeToJson(const vint& value); + template<> Ptr ConvertCustomTypeToJson(const float& value); + template<> Ptr ConvertCustomTypeToJson(const double& value); + template<> Ptr ConvertCustomTypeToJson(const WString& value); + template<> Ptr ConvertCustomTypeToJson(const wchar_t& value); + template<> Ptr ConvertCustomTypeToJson(const VKEY& value); + + template + void ConvertJsonToCustomType(Ptr node, T& value) + { + return JsonHelper::FromJson(node, value); + } + + template<> void ConvertJsonToCustomType(Ptr node, bool& value); + template<> void ConvertJsonToCustomType(Ptr node, vint& value); + template<> void ConvertJsonToCustomType(Ptr node, float& value); + template<> void ConvertJsonToCustomType(Ptr node, double& value); + template<> void ConvertJsonToCustomType(Ptr node, WString& value); + template<> void ConvertJsonToCustomType(Ptr node, wchar_t& value); + template<> void ConvertJsonToCustomType(Ptr node, VKEY& value); + + template + void ConvertCustomTypeToJsonField(Ptr node, const wchar_t* name, const T& value) + { + auto field = Ptr(new glr::json::JsonObjectField); + field->name.value = WString::Unmanaged(name); + field->value = ConvertCustomTypeToJson(value); + node->fields.Add(field); + } + + template + struct JsonHelper>> + { + static Ptr ToJson(const Ptr>& value) + { + if (!value) + { + auto node = Ptr(new glr::json::JsonLiteral); + node->value = glr::json::JsonLiteralValue::Null; + return node; + } + else + { + auto node = Ptr(new glr::json::JsonArray); + for (auto&& item : *value.Obj()) + { + node->items.Add(ConvertCustomTypeToJson(item)); + } + return node; + } + } + + static void FromJson(Ptr node, Ptr>& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType(Ptr, Ptr>&)#" + if (auto jsonLiteral = node.Cast()) + { + if (jsonLiteral->value == glr::json::JsonLiteralValue::Null) + { + value = {}; + return; + } + } + else if (auto jsonArray = node.Cast()) + { + value = Ptr(new collections::List); + for (auto jsonItem : jsonArray->items) + { + T item; + ConvertJsonToCustomType(jsonItem, item); + value->Add(std::move(item)); + } + return; + } + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); +#undef ERROR_MESSAGE_PREFIX + } + }; +} + +#endif + + +/*********************************************************************** +.\PLATFORMPROVIDERS\REMOTE\PROTOCOL\GENERATED\GUIREMOTEPROTOCOLSCHEMA.H +***********************************************************************/ +/*********************************************************************** +This file is generated by : Vczh GacUI Remote Protocol Generator +Licensed under https ://github.com/vczh-libraries/License +***********************************************************************/ + +#ifndef VCZH_PRESENTATION_GUIREMOTECONTROLLER_REMOTEPROTOCOLSCHEMA +#define VCZH_PRESENTATION_GUIREMOTECONTROLLER_REMOTEPROTOCOLSCHEMA + + +namespace vl::presentation::remoteprotocol +{ + enum class IOMouseButton + { + Left, + Middle, + Right, + }; + + struct FontConfig + { + ::vl::presentation::FontProperties defaultFont; + ::vl::Ptr<::vl::collections::List<::vl::WString>> supportedFonts; + }; + + struct ScreenConfig + { + ::vl::presentation::NativeRect bounds; + ::vl::presentation::NativeRect clientBounds; + double scalingX; + double scalingY; + }; + + struct IOMouseInfoWithButton + { + vl::presentation::remoteprotocol::IOMouseButton button; + ::vl::presentation::NativeWindowMouseInfo info; + }; + + struct GlobalShortcutKey + { + ::vl::vint id; + bool ctrl; + bool shift; + bool alt; + ::vl::presentation::VKEY code; + }; + + struct WindowSizingConfig + { + ::vl::presentation::NativeRect bounds; + ::vl::presentation::NativeRect clientBounds; + ::vl::presentation::INativeWindow::WindowSizeState sizeState; + ::vl::presentation::NativeMargin customFramePadding; + }; + + struct WindowShowing + { + bool activate; + ::vl::presentation::INativeWindow::WindowSizeState sizeState; + }; + + template<> vl::Ptr ConvertCustomTypeToJson(const vl::presentation::remoteprotocol::IOMouseButton & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::INativeWindow::WindowSizeState>(const ::vl::presentation::INativeWindow::WindowSizeState & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativeCoordinate>(const ::vl::presentation::NativeCoordinate & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativePoint>(const ::vl::presentation::NativePoint & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativeSize>(const ::vl::presentation::NativeSize & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativeRect>(const ::vl::presentation::NativeRect & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativeMargin>(const ::vl::presentation::NativeMargin & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::FontProperties>(const ::vl::presentation::FontProperties & value); + template<> vl::Ptr ConvertCustomTypeToJson(const vl::presentation::remoteprotocol::FontConfig & value); + template<> vl::Ptr ConvertCustomTypeToJson(const vl::presentation::remoteprotocol::ScreenConfig & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativeWindowMouseInfo>(const ::vl::presentation::NativeWindowMouseInfo & value); + template<> vl::Ptr ConvertCustomTypeToJson(const vl::presentation::remoteprotocol::IOMouseInfoWithButton & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativeWindowKeyInfo>(const ::vl::presentation::NativeWindowKeyInfo & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativeWindowCharInfo>(const ::vl::presentation::NativeWindowCharInfo & value); + template<> vl::Ptr ConvertCustomTypeToJson(const vl::presentation::remoteprotocol::GlobalShortcutKey & value); + template<> vl::Ptr ConvertCustomTypeToJson(const vl::presentation::remoteprotocol::WindowSizingConfig & value); + template<> vl::Ptr ConvertCustomTypeToJson(const vl::presentation::remoteprotocol::WindowShowing & value); + + template<> void ConvertJsonToCustomType(vl::Ptr node, vl::presentation::remoteprotocol::IOMouseButton& value); + template<> void ConvertJsonToCustomType<::vl::presentation::INativeWindow::WindowSizeState>(vl::Ptr node, ::vl::presentation::INativeWindow::WindowSizeState& value); + template<> void ConvertJsonToCustomType<::vl::presentation::NativeCoordinate>(vl::Ptr node, ::vl::presentation::NativeCoordinate& value); + template<> void ConvertJsonToCustomType<::vl::presentation::NativePoint>(vl::Ptr node, ::vl::presentation::NativePoint& value); + template<> void ConvertJsonToCustomType<::vl::presentation::NativeSize>(vl::Ptr node, ::vl::presentation::NativeSize& value); + template<> void ConvertJsonToCustomType<::vl::presentation::NativeRect>(vl::Ptr node, ::vl::presentation::NativeRect& value); + template<> void ConvertJsonToCustomType<::vl::presentation::NativeMargin>(vl::Ptr node, ::vl::presentation::NativeMargin& value); + template<> void ConvertJsonToCustomType<::vl::presentation::FontProperties>(vl::Ptr node, ::vl::presentation::FontProperties& value); + template<> void ConvertJsonToCustomType(vl::Ptr node, vl::presentation::remoteprotocol::FontConfig& value); + template<> void ConvertJsonToCustomType(vl::Ptr node, vl::presentation::remoteprotocol::ScreenConfig& value); + template<> void ConvertJsonToCustomType<::vl::presentation::NativeWindowMouseInfo>(vl::Ptr node, ::vl::presentation::NativeWindowMouseInfo& value); + template<> void ConvertJsonToCustomType(vl::Ptr node, vl::presentation::remoteprotocol::IOMouseInfoWithButton& value); + template<> void ConvertJsonToCustomType<::vl::presentation::NativeWindowKeyInfo>(vl::Ptr node, ::vl::presentation::NativeWindowKeyInfo& value); + template<> void ConvertJsonToCustomType<::vl::presentation::NativeWindowCharInfo>(vl::Ptr node, ::vl::presentation::NativeWindowCharInfo& value); + template<> void ConvertJsonToCustomType(vl::Ptr node, vl::presentation::remoteprotocol::GlobalShortcutKey& value); + template<> void ConvertJsonToCustomType(vl::Ptr node, vl::presentation::remoteprotocol::WindowSizingConfig& value); + template<> void ConvertJsonToCustomType(vl::Ptr node, vl::presentation::remoteprotocol::WindowShowing& value); + +#define GACUI_REMOTEPROTOCOL_MESSAGES(HANDLER)\ + HANDLER(ControllerGetFontConfig, void, vl::presentation::remoteprotocol::FontConfig, NOREQ, RES, NODROP)\ + HANDLER(ControllerGetScreenConfig, void, vl::presentation::remoteprotocol::ScreenConfig, NOREQ, RES, NODROP)\ + HANDLER(ControllerConnectionEstablished, void, void, NOREQ, NORES, NODROP)\ + HANDLER(ControllerConnectionStopped, void, void, NOREQ, NORES, NODROP)\ + HANDLER(IOUpdateGlobalShortcutKey, ::vl::Ptr<::vl::collections::List>, void, REQ, NORES, NODROP)\ + HANDLER(IORequireCapture, void, void, NOREQ, NORES, NODROP)\ + HANDLER(IOReleaseCapture, void, void, NOREQ, NORES, NODROP)\ + HANDLER(IOIsKeyPressing, ::vl::presentation::VKEY, bool, REQ, RES, NODROP)\ + HANDLER(IOIsKeyToggled, ::vl::presentation::VKEY, bool, REQ, RES, NODROP)\ + HANDLER(WindowGetBounds, void, vl::presentation::remoteprotocol::WindowSizingConfig, NOREQ, RES, NODROP)\ + HANDLER(WindowNotifySetTitle, ::vl::WString, void, REQ, NORES, DROPREP)\ + HANDLER(WindowNotifySetEnabled, bool, void, REQ, NORES, DROPREP)\ + HANDLER(WindowNotifySetTopMost, bool, void, REQ, NORES, DROPREP)\ + HANDLER(WindowNotifySetShowInTaskBar, bool, void, REQ, NORES, DROPREP)\ + HANDLER(WindowNotifySetCustomFrameMode, bool, void, REQ, NORES, DROPREP)\ + HANDLER(WindowNotifySetMaximizedBox, bool, void, REQ, NORES, DROPREP)\ + HANDLER(WindowNotifySetMinimizedBox, bool, void, REQ, NORES, DROPREP)\ + HANDLER(WindowNotifySetBorder, bool, void, REQ, NORES, DROPREP)\ + HANDLER(WindowNotifySetSizeBox, bool, void, REQ, NORES, DROPREP)\ + HANDLER(WindowNotifySetIconVisible, bool, void, REQ, NORES, DROPREP)\ + HANDLER(WindowNotifySetTitleBar, bool, void, REQ, NORES, DROPREP)\ + HANDLER(WindowNotifySetBounds, ::vl::presentation::NativeRect, void, REQ, NORES, DROPREP)\ + HANDLER(WindowNotifySetClientSize, ::vl::presentation::NativeSize, void, REQ, NORES, DROPREP)\ + HANDLER(WindowNotifyActivate, void, void, NOREQ, NORES, DROPREP)\ + HANDLER(WindowNotifyShow, vl::presentation::remoteprotocol::WindowShowing, void, REQ, NORES, DROPREP)\ + +#define GACUI_REMOTEPROTOCOL_EVENTS(HANDLER)\ + HANDLER(ControllerConnect, void, NOREQ, NODROP)\ + HANDLER(ControllerDisconnect, void, NOREQ, NODROP)\ + HANDLER(ControllerRequestExit, void, NOREQ, NODROP)\ + HANDLER(ControllerForceExit, void, NOREQ, NODROP)\ + HANDLER(ControllerScreenUpdated, vl::presentation::remoteprotocol::ScreenConfig, REQ, DROPREP)\ + HANDLER(IOGlobalShortcutKey, ::vl::vint, REQ, NODROP)\ + HANDLER(IOButtonDown, vl::presentation::remoteprotocol::IOMouseInfoWithButton, REQ, NODROP)\ + HANDLER(IOButtonDoubleClick, vl::presentation::remoteprotocol::IOMouseInfoWithButton, REQ, NODROP)\ + HANDLER(IOButtonUp, vl::presentation::remoteprotocol::IOMouseInfoWithButton, REQ, NODROP)\ + HANDLER(IOHWheel, ::vl::presentation::NativeWindowMouseInfo, REQ, NODROP)\ + HANDLER(IOVWheel, ::vl::presentation::NativeWindowMouseInfo, REQ, NODROP)\ + HANDLER(IOMouseMoving, ::vl::presentation::NativeWindowMouseInfo, REQ, DROPCON)\ + HANDLER(IOMouseEntered, void, NOREQ, NODROP)\ + HANDLER(IOMouseLeaved, void, NOREQ, NODROP)\ + HANDLER(IOKeyDown, ::vl::presentation::NativeWindowKeyInfo, REQ, NODROP)\ + HANDLER(IOKeyUp, ::vl::presentation::NativeWindowKeyInfo, REQ, NODROP)\ + HANDLER(IOChar, ::vl::presentation::NativeWindowCharInfo, REQ, NODROP)\ + HANDLER(WindowBoundsUpdated, vl::presentation::remoteprotocol::WindowSizingConfig, REQ, DROPREP)\ + HANDLER(WindowActivatedUpdated, bool, REQ, DROPREP)\ + +} + +#endif + + +/*********************************************************************** +.\PLATFORMPROVIDERS\REMOTE\GUIREMOTEPROTOCOL.H +***********************************************************************/ +/*********************************************************************** +Vczh Library++ 3.0 +Developer: Zihan Chen(vczh) +GacUI::Remote Window + +Interfaces: + IGuiRemoteProtocol + +***********************************************************************/ + +#ifndef VCZH_PRESENTATION_GUIREMOTECONTROLLER_GUIREMOTEPROTOCOL +#define VCZH_PRESENTATION_GUIREMOTECONTROLLER_GUIREMOTEPROTOCOL + + +namespace vl::presentation +{ +/*********************************************************************** +IGuiRemoteProtocolEvents +***********************************************************************/ + + class IGuiRemoteProtocolEvents : public virtual Interface + { + public: +#define EVENT_NOREQ(NAME, REQUEST) virtual void On ## NAME() = 0; +#define EVENT_REQ(NAME, REQUEST) virtual void On ## NAME(const REQUEST& arguments) = 0; +#define EVENT_HANDLER(NAME, REQUEST, REQTAG, ...) EVENT_ ## REQTAG(NAME, REQUEST) + GACUI_REMOTEPROTOCOL_EVENTS(EVENT_HANDLER) +#undef EVENT_HANDLER +#undef EVENT_REQ +#undef EVENT_NOREQ + +#define MESSAGE_NORES(NAME, RESPONSE) +#define MESSAGE_RES(NAME, RESPONSE) virtual void Respond ## NAME(vint id, const RESPONSE& arguments) = 0; +#define MESSAGE_HANDLER(NAME, REQUEST, RESPONSE, REQTAG, RESTAG, ...) MESSAGE_ ## RESTAG(NAME, RESPONSE) + GACUI_REMOTEPROTOCOL_MESSAGES(MESSAGE_HANDLER) +#undef MESSAGE_HANDLER +#undef MESSAGE_RES +#undef MESSAGE_NORES + }; + +/*********************************************************************** +IGuiRemoteProtocolMessages +***********************************************************************/ + + class IGuiRemoteProtocolMessages : public virtual Interface + { + public: +#define MESSAGE_NOREQ_NORES(NAME, REQUEST, RESPONSE) virtual void Request ## NAME() = 0; +#define MESSAGE_NOREQ_RES(NAME, REQUEST, RESPONSE) virtual void Request ## NAME(vint id) = 0; +#define MESSAGE_REQ_NORES(NAME, REQUEST, RESPONSE) virtual void Request ## NAME(const REQUEST& arguments) = 0; +#define MESSAGE_REQ_RES(NAME, REQUEST, RESPONSE) virtual void Request ## NAME(vint id, const REQUEST& arguments) = 0; +#define MESSAGE_HANDLER(NAME, REQUEST, RESPONSE, REQTAG, RESTAG, ...) MESSAGE_ ## REQTAG ## _ ## RESTAG(NAME, REQUEST, RESPONSE) + GACUI_REMOTEPROTOCOL_MESSAGES(MESSAGE_HANDLER) +#undef MESSAGE_HANDLER +#undef MESSAGE_REQ_RES +#undef MESSAGE_REQ_NORES +#undef MESSAGE_NOREQ_RES +#undef MESSAGE_NOREQ_NORES + }; + +/*********************************************************************** +IGuiRemoteProtocolConfig +***********************************************************************/ + + class IGuiRemoteProtocolConfig : public virtual Interface + { + public: + virtual WString GetExecutablePath() = 0; + }; + +/*********************************************************************** +IGuiRemoteProtocol +***********************************************************************/ + + class IGuiRemoteProtocol + : public virtual IGuiRemoteProtocolConfig + , public virtual IGuiRemoteProtocolMessages + { + public: + virtual void Initialize(IGuiRemoteProtocolEvents* events) = 0; + virtual void Submit() = 0; + virtual void ProcessRemoteEvents() = 0; + }; +} + +#endif + /*********************************************************************** .\RESOURCES\GUIPLUGINMANAGER.H ***********************************************************************/ @@ -22294,6 +22838,13 @@ using namespace vl::presentation::templates; // GacUI Compiler extern int SetupGacGenNativeController(); +// Remote +namespace vl::presentation +{ + class IGuiRemoteProtocol; +} +extern int SetupRemoteNativeController(vl::presentation::IGuiRemoteProtocol* protocol); + // Windows extern int SetupWindowsGDIRenderer(); extern int SetupWindowsDirect2DRenderer(); @@ -25812,3 +26363,440 @@ GuiHostedController } #endif + +/*********************************************************************** +.\PLATFORMPROVIDERS\REMOTE\GUIREMOTEEVENTS.H +***********************************************************************/ +/*********************************************************************** +Vczh Library++ 3.0 +Developer: Zihan Chen(vczh) +GacUI::Remote Window + +Interfaces: + GuiRemoteEvent + +***********************************************************************/ + +#ifndef VCZH_PRESENTATION_GUIREMOTECONTROLLER_GUIREMOTEEVENT +#define VCZH_PRESENTATION_GUIREMOTECONTROLLER_GUIREMOTEEVENT + + +namespace vl::presentation +{ + class GuiRemoteController; + +/*********************************************************************** +GuiRemoteMessages +***********************************************************************/ + + class GuiRemoteMessages : public Object + { + protected: + GuiRemoteController* remote; + vint id = 0; + +#define MESSAGE_NORES(NAME, RESPONSE) +#define MESSAGE_RES(NAME, RESPONSE) collections::Dictionary response ## NAME; +#define MESSAGE_HANDLER(NAME, REQUEST, RESPONSE, REQTAG, RESTAG, ...) MESSAGE_ ## RESTAG(NAME, RESPONSE) + GACUI_REMOTEPROTOCOL_MESSAGES(MESSAGE_HANDLER) +#undef MESSAGE_HANDLER +#undef MESSAGE_RES +#undef MESSAGE_NORES + + public: + GuiRemoteMessages(GuiRemoteController* _remote); + ~GuiRemoteMessages(); + + void Submit(); + void ClearResponses(); + + // messages + +#define MESSAGE_NOREQ_NORES(NAME, REQUEST, RESPONSE) void Request ## NAME(); +#define MESSAGE_NOREQ_RES(NAME, REQUEST, RESPONSE) vint Request ## NAME(); +#define MESSAGE_REQ_NORES(NAME, REQUEST, RESPONSE) void Request ## NAME(const REQUEST& arguments); +#define MESSAGE_REQ_RES(NAME, REQUEST, RESPONSE) vint Request ## NAME(const REQUEST& arguments); +#define MESSAGE_HANDLER(NAME, REQUEST, RESPONSE, REQTAG, RESTAG, ...) MESSAGE_ ## REQTAG ## _ ## RESTAG(NAME, REQUEST, RESPONSE) + GACUI_REMOTEPROTOCOL_MESSAGES(MESSAGE_HANDLER) +#undef MESSAGE_HANDLER +#undef MESSAGE_REQ_RES +#undef MESSAGE_REQ_NORES +#undef MESSAGE_NOREQ_RES +#undef MESSAGE_NOREQ_NORES + +#define MESSAGE_NORES(NAME, RESPONSE) +#define MESSAGE_RES(NAME, RESPONSE)\ + void Respond ## NAME(vint id, const RESPONSE& arguments);\ + const RESPONSE& Retrieve ## NAME(vint id);\ + +#define MESSAGE_HANDLER(NAME, REQUEST, RESPONSE, REQTAG, RESTAG, ...) MESSAGE_ ## RESTAG(NAME, RESPONSE) + GACUI_REMOTEPROTOCOL_MESSAGES(MESSAGE_HANDLER) +#undef MESSAGE_HANDLER +#undef MESSAGE_RES +#undef MESSAGE_NORES + }; + +/*********************************************************************** +GuiRemoteEvents +***********************************************************************/ + + class GuiRemoteEvents : public Object, public virtual IGuiRemoteProtocolEvents + { + protected: + GuiRemoteController* remote; + + public: + GuiRemoteEvents(GuiRemoteController* _remote); + ~GuiRemoteEvents(); + + // ============================================================= + // IGuiRemoteProtocolEvents + // ============================================================= + + // messages + +#define MESSAGE_NORES(NAME, RESPONSE) +#define MESSAGE_RES(NAME, RESPONSE) void Respond ## NAME(vint id, const RESPONSE& arguments) override; +#define MESSAGE_HANDLER(NAME, REQUEST, RESPONSE, REQTAG, RESTAG, ...) MESSAGE_ ## RESTAG(NAME, RESPONSE) + GACUI_REMOTEPROTOCOL_MESSAGES(MESSAGE_HANDLER) +#undef MESSAGE_HANDLER +#undef MESSAGE_RES +#undef MESSAGE_NORES + + void ClearResponses(); + + // events + +#define EVENT_NOREQ(NAME, REQUEST) void On ## NAME() override; +#define EVENT_REQ(NAME, REQUEST) void On ## NAME(const REQUEST& arguments) override; +#define EVENT_HANDLER(NAME, REQUEST, REQTAG, ...) EVENT_ ## REQTAG(NAME, REQUEST) + GACUI_REMOTEPROTOCOL_EVENTS(EVENT_HANDLER) +#undef EVENT_HANDLER +#undef EVENT_REQ +#undef EVENT_NOREQ + }; +} + +#endif + +/*********************************************************************** +.\PLATFORMPROVIDERS\REMOTE\GUIREMOTEWINDOW.H +***********************************************************************/ +/*********************************************************************** +Vczh Library++ 3.0 +Developer: Zihan Chen(vczh) +GacUI::Remote Window + +Interfaces: + GuiRemoteController + +***********************************************************************/ + +#ifndef VCZH_PRESENTATION_GUIREMOTECONTROLLER_GUIREMOTEWINDOW +#define VCZH_PRESENTATION_GUIREMOTECONTROLLER_GUIREMOTEWINDOW + + +namespace vl::presentation +{ + class GuiRemoteController; + +/*********************************************************************** +GuiRemoteWindow +***********************************************************************/ + + class GuiRemoteWindow : public Object, public virtual INativeWindow + { + friend class GuiRemoteEvents; + friend class GuiRemoteController; + protected: + GuiRemoteController* remote; + GuiRemoteMessages& remoteMessages; + GuiRemoteEvents& remoteEvents; + collections::List listeners; + INativeWindow::WindowMode windowMode = INativeWindow::Normal; + + bool disconnected = false; + remoteprotocol::WindowSizingConfig remoteWindowSizingConfig; + bool sizingConfigInvalidated = false; + double scalingX = 1; + double scalingY = 1; + + WString styleTitle; + INativeCursor* styleCursor = nullptr; + NativePoint styleCaret; + Ptr styleIcon; + bool styleEnabled = true; + bool styleTopMost = false; + + bool styleMaximizedBox = true; + bool styleMinimizedBox = true; + bool styleBorder = true; + bool styleSizeBox = true; + bool styleIconVisible = true; + bool styleTitleBar = true; + bool styleShowInTaskBar = true; + bool styleCustomFrameMode = false; + + bool statusVisible = false; + bool statusActivated = false; + bool statusCapturing = false; + + void RequestGetBounds(); + void Opened(); + void SetActivated(bool activated); + void ShowWithSizeState(bool activate, INativeWindow::WindowSizeState sizeState); + + // ============================================================= + // Events + // ============================================================= + + void OnControllerConnect(); + void OnControllerDisconnect(); + void OnControllerScreenUpdated(const remoteprotocol::ScreenConfig& arguments); + void OnWindowBoundsUpdated(const remoteprotocol::WindowSizingConfig& arguments); + void OnWindowActivatedUpdated(bool activated); + + public: + GuiRemoteWindow(GuiRemoteController* _remote); + ~GuiRemoteWindow(); + + // ============================================================= + // INativeWindow + // ============================================================= + + bool IsActivelyRefreshing() override; + NativeSize GetRenderingOffset() override; + Point Convert(NativePoint value) override; + NativePoint Convert(Point value) override; + Size Convert(NativeSize value) override; + NativeSize Convert(Size value) override; + Margin Convert(NativeMargin value) override; + NativeMargin Convert(Margin value) override; + NativeRect GetBounds() override; + void SetBounds(const NativeRect& bounds) override; + NativeSize GetClientSize() override; + void SetClientSize(NativeSize size) override; + NativeRect GetClientBoundsInScreen() override; + WString GetTitle() override; + void SetTitle(const WString& title) override; + INativeCursor* GetWindowCursor() override; + void SetWindowCursor(INativeCursor* cursor) override; + NativePoint GetCaretPoint() override; + void SetCaretPoint(NativePoint point) override; + INativeWindow* GetParent() override; + void SetParent(INativeWindow* parent) override; + WindowMode GetWindowMode() override; + void EnableCustomFrameMode() override; + void DisableCustomFrameMode() override; + bool IsCustomFrameModeEnabled() override; + NativeMargin GetCustomFramePadding() override; + Ptr GetIcon() override; + void SetIcon(Ptr icon) override; + WindowSizeState GetSizeState() override; + void Show() override; + void ShowDeactivated() override; + void ShowRestored() override; + void ShowMaximized() override; + void ShowMinimized() override; + void Hide(bool closeWindow) override; + bool IsVisible() override; + void Enable() override; + void Disable() override; + bool IsEnabled() override; + void SetActivate() override; + bool IsActivated() override; + bool IsRenderingAsActivated() override; + void ShowInTaskBar() override; + void HideInTaskBar() override; + bool IsAppearedInTaskBar() override; + void EnableActivate() override; + void DisableActivate() override; + bool IsEnabledActivate() override; + bool RequireCapture() override; + bool ReleaseCapture() override; + bool IsCapturing() override; + bool GetMaximizedBox() override; + void SetMaximizedBox(bool visible) override; + bool GetMinimizedBox() override; + void SetMinimizedBox(bool visible) override; + bool GetBorder() override; + void SetBorder(bool visible) override; + bool GetSizeBox() override; + void SetSizeBox(bool visible) override; + bool GetIconVisible() override; + void SetIconVisible(bool visible) override; + bool GetTitleBar() override; + void SetTitleBar(bool visible) override; + bool GetTopMost() override; + void SetTopMost(bool topmost) override; + void SupressAlt() override; + bool InstallListener(INativeWindowListener* listener) override; + bool UninstallListener(INativeWindowListener* listener) override; + void RedrawContent() override; + }; +} + +#endif + +/*********************************************************************** +.\PLATFORMPROVIDERS\REMOTE\GUIREMOTECONTROLLER.H +***********************************************************************/ +/*********************************************************************** +Vczh Library++ 3.0 +Developer: Zihan Chen(vczh) +GacUI::Remote Window + +Interfaces: + GuiRemoteController + +***********************************************************************/ + +#ifndef VCZH_PRESENTATION_GUIREMOTECONTROLLER +#define VCZH_PRESENTATION_GUIREMOTECONTROLLER + + +namespace vl::presentation +{ +/*********************************************************************** +GuiRemoteController +***********************************************************************/ + + class GuiRemoteController + : public Object + , public INativeController + , protected INativeResourceService + , protected INativeInputService + , protected INativeScreenService + , protected INativeScreen + , protected INativeWindowService + { + friend class GuiRemoteMessages; + friend class GuiRemoteEvents; + friend class GuiRemoteWindow; + friend class elements::GuiRemoteGraphicsRenderTarget; + friend class elements::GuiRemoteGraphicsResourceManager; + using CursorMap = collections::Dictionary>; + using HotKeyEntry = Tuple; + using HotKeySet = collections::SortedList; + using HotKeyIds = collections::Dictionary; + protected: + IGuiRemoteProtocol* remoteProtocol; + GuiRemoteMessages remoteMessages; + GuiRemoteEvents remoteEvents; + GuiRemoteWindow remoteWindow; + SharedCallbackService callbackService; + SharedAsyncService asyncService; + bool applicationRunning = false; + bool connectionForcedToStop = false; + bool connectionStopped = false; + + remoteprotocol::FontConfig remoteFontConfig; + remoteprotocol::ScreenConfig remoteScreenConfig; + + vint usedHotKeys = (vint)NativeGlobalShortcutKeyResult::ValidIdBegins; + HotKeySet hotKeySet; + HotKeyIds hotKeyIds; + + CursorMap cursors; + bool timerEnabled = false; + bool windowCreated = false; + bool windowDestroyed = false; + + collections::Dictionary keyNames; + collections::Dictionary keyCodes; + bool keyInitialized = false; + + // ============================================================= + // INativeResourceService + // ============================================================= + + INativeCursor* GetSystemCursor(INativeCursor::SystemCursorType type) override; + INativeCursor* GetDefaultSystemCursor() override; + FontProperties GetDefaultFont() override; + void SetDefaultFont(const FontProperties& value) override; + void EnumerateFonts(collections::List& fonts) override; + + // ============================================================= + // INativeInputService + // ============================================================= + + void StartTimer() override; + void StopTimer() override; + bool IsTimerEnabled() override; + bool IsKeyPressing(VKEY code) override; + bool IsKeyToggled(VKEY code) override; + void EnsureKeyInitialized(); + WString GetKeyName(VKEY code) override; + VKEY GetKey(const WString& name) override; + void UpdateGlobalShortcutKey(); + vint RegisterGlobalShortcutKey(bool ctrl, bool shift, bool alt, VKEY key) override; + bool UnregisterGlobalShortcutKey(vint id) override; + + // ============================================================= + // INativeScreenService + // ============================================================= + + vint GetScreenCount() override; + INativeScreen* GetScreen(vint index) override; + INativeScreen* GetScreen(INativeWindow* window) override; + + // ============================================================= + // INativeScreen + // ============================================================= + + NativeRect GetBounds() override; + NativeRect GetClientBounds() override; + WString GetName() override; + bool IsPrimary() override; + double GetScalingX() override; + double GetScalingY() override; + + // ============================================================= + // INativeWindowService + // ============================================================= + + const NativeWindowFrameConfig& GetMainWindowFrameConfig() override; + const NativeWindowFrameConfig& GetNonMainWindowFrameConfig() override; + INativeWindow* CreateNativeWindow(INativeWindow::WindowMode windowMode) override; + void DestroyNativeWindow(INativeWindow* window) override; + INativeWindow* GetMainWindow() override; + INativeWindow* GetWindow(NativePoint location) override; + void Run(INativeWindow* window) override; + bool RunOneCycle() override; + + // ============================================================= + // Events + // ============================================================= + + void OnControllerConnect(); + void OnControllerDisconnect(); + void OnControllerRequestExit(); + void OnControllerForceExit(); + void OnControllerScreenUpdated(const remoteprotocol::ScreenConfig& arguments); + + public: + GuiRemoteController(IGuiRemoteProtocol* _remoteProtocol); + ~GuiRemoteController(); + + void Initialize(); + void Finalize(); + + // ============================================================= + // INativeController + // ============================================================= + + INativeCallbackService* CallbackService() override; + INativeResourceService* ResourceService() override; + INativeAsyncService* AsyncService() override; + INativeClipboardService* ClipboardService() override; + INativeImageService* ImageService() override; + INativeInputService* InputService() override; + INativeDialogService* DialogService() override; + WString GetExecutablePath() override; + + INativeScreenService* ScreenService() override; + INativeWindowService* WindowService() override; + }; +} + +#endif diff --git a/Import/GacUICompiler.cpp b/Import/GacUICompiler.cpp index aedd597b..e47c9db7 100644 --- a/Import/GacUICompiler.cpp +++ b/Import/GacUICompiler.cpp @@ -10461,6 +10461,1825 @@ namespace vl::presentation::instancequery } +/*********************************************************************** +.\REMOTEPROTOCOL\GUIREMOTEPROTOCOLCOMPILER.CPP +***********************************************************************/ + +namespace vl::presentation +{ + using namespace collections; + using namespace remoteprotocol; + +/*********************************************************************** +CheckRemoteProtocolSchema +***********************************************************************/ + + class GuiRpCheckSchemaVisitor + : public Object + , public GuiRpType::IVisitor + , public GuiRpDeclaration::IVisitor + { + protected: + Ptr symbols; + List& errors; + + public: + GuiRpCheckSchemaVisitor(Ptr _symbols, List& _errors) + : symbols(_symbols) + , errors(_errors) + { + } + + // GuiRpType::IVisitor + + void Visit(GuiRpPrimitiveType* node) override + { + } + + void Visit(GuiRpReferenceType* node) override + { + if (!symbols->enumDecls.Keys().Contains(node->name.value) && !symbols->structDecls.Keys().Contains(node->name.value)) + { + errors.Add({ node->name.codeRange,L"Custom type \"" + node->name.value + L"\" not found." }); + } + } + + void Visit(GuiRpArrayType* node) override + { + node->element->Accept(this); + } + + // GuiRpDeclaration::IVisitor + + bool EnsureTypeUndefined(const glr::ParsingToken& name) + { + if (symbols->enumDecls.Keys().Contains(name.value)) + { + errors.Add({ name.codeRange,L"Enum \"" + name.value + L"\" already defined." }); + return false; + } + if (symbols->structDecls.Keys().Contains(name.value)) + { + errors.Add({ name.codeRange,L"Struct \"" + name.value + L"\" already defined." }); + return false; + } + return true; + } + + void Visit(GuiRpEnumDecl* node) override + { + if (!EnsureTypeUndefined(node->name)) return; + + SortedList memberNames; + for (auto member : node->members) + { + if (memberNames.Contains(member->name.value)) + { + errors.Add({ member->name.codeRange,L"Enum member \"" + node->name.value + L"::" + member->name.value + L"\" already exists." }); + } + else + { + memberNames.Add(member->name.value); + } + } + + for (auto att : node->attributes) + { + if (att->name.value == L"@Cpp") + { + if (!att->cppType) + { + errors.Add({ att->name.codeRange,L"Missing parameter for attribute: \"" + att->name.value + L"\"." }); + } + else + { + symbols->cppMapping.Add(node->name.value, att->cppType.value); + } + } + else + { + errors.Add({ att->name.codeRange,L"Unsupported attribute: \"" + att->name.value + L"\" on enum \"" + node->name.value + L"\"." }); + } + } + symbols->enumDecls.Add(node->name.value, node); + } + + void Visit(GuiRpStructDecl* node) override + { + if (!EnsureTypeUndefined(node->name)) return; + + SortedList memberNames; + for (auto member : node->members) + { + if (memberNames.Contains(member->name.value)) + { + errors.Add({ member->name.codeRange,L"Struct member \"" + node->name.value + L"::" + member->name.value + L"\" already exists." }); + } + else + { + memberNames.Add(member->name.value); + } + member->type->Accept(this); + } + + for (auto att : node->attributes) + { + if (att->name.value == L"@Cpp") + { + if (!att->cppType) + { + errors.Add({ att->name.codeRange,L"Missing parameter for attribute: \"" + att->name.value + L"\"." }); + } + else if (symbols->cppMapping.Keys().Contains(node->name.value)) + { + errors.Add({ att->name.codeRange,L"Too many attributes: \"" + att->name.value + L"\"." }); + } + else + { + symbols->cppMapping.Add(node->name.value, att->cppType.value); + } + } + else + { + errors.Add({ att->name.codeRange,L"Unsupported attribute: \"" + att->name.value + L"\" on struct \"" + node->name.value + L"\"." }); + } + } + symbols->structDecls.Add(node->name.value, node); + } + + void VisitDropAttribute(Ptr att, const WString& name, SortedList& names) + { + if (names.Contains(name)) + { + errors.Add({ att->name.codeRange,L"Too many attributes: \"" + att->name.value + L"\"." }); + } + else + { + names.Add(name); + } + } + + void Visit(GuiRpMessageDecl* node) override + { + if (symbols->messageDecls.Keys().Contains(node->name.value)) + { + errors.Add({ node->name.codeRange,L"Message \"" + node->name.value + L"\" already exists." }); + return; + } + + if (node->request) + { + node->request->type->Accept(this); + } + + if (node->response) + { + node->response->type->Accept(this); + } + + for (auto att : node->attributes) + { + if (att->name.value == L"@DropRepeat") + { + if (node->response) + { + errors.Add({ node->name.codeRange,L"@DropRepeat cannot be used on message \"" + node->name.value + L"\" since it has response." }); + } + VisitDropAttribute(att, node->name.value, symbols->dropRepeatDeclNames); + } + else + { + errors.Add({ att->name.codeRange,L"Unsupported attribute: \"" + att->name.value + L"\" on message \"" + node->name.value + L"\"." }); + } + } + symbols->messageDecls.Add(node->name.value, node); + } + + void Visit(GuiRpEventDecl* node) override + { + if (symbols->eventDecls.Keys().Contains(node->name.value)) + { + errors.Add({ node->name.codeRange,L"Event \"" + node->name.value + L"\" already exists." }); + return; + } + + if (node->request) + { + node->request->type->Accept(this); + } + + for (auto att : node->attributes) + { + if (att->name.value == L"@DropRepeat") + { + VisitDropAttribute(att, node->name.value, symbols->dropRepeatDeclNames); + } + else if (att->name.value == L"@DropConsecutive") + { + VisitDropAttribute(att, node->name.value, symbols->dropConsecutiveDeclNames); + } + else + { + errors.Add({ att->name.codeRange,L"Unsupported attribute: \"" + att->name.value + L"\" on event \"" + node->name.value + L"\"." }); + } + } + + if (symbols->dropRepeatDeclNames.Contains(node->name.value) && symbols->dropConsecutiveDeclNames.Contains(node->name.value)) + { + errors.Add({ node->name.codeRange,L"@DropRepeat and @DropConsecutive cannot be used together on event \"" + node->name.value + L"\"." }); + } + symbols->eventDecls.Add(node->name.value, node); + } + }; + + Ptr CheckRemoteProtocolSchema(Ptr schema, collections::List& errors) + { + auto symbols = Ptr(new GuiRpSymbols); + GuiRpCheckSchemaVisitor visitor(symbols, errors); + for (auto decl : schema->declarations) + { + decl->Accept(&visitor); + } + return symbols; + } + +/*********************************************************************** +GenerateRemoteProtocolHeaderFile +***********************************************************************/ + + class GuiRpPrintTypeVisitor : public Object, public GuiRpType::IVisitor + { + protected: + Ptr symbols; + GuiRpCppConfig& config; + stream::TextWriter& writer; + + public: + GuiRpPrintTypeVisitor(Ptr _symbols, GuiRpCppConfig& _config, stream::TextWriter& _writer) + : symbols(_symbols) + , config(_config) + , writer(_writer) + { + } + + // GuiRpType::IVisitor + + void Visit(GuiRpPrimitiveType* node) override + { + switch (node->type) + { + case GuiRpPrimitiveTypes::Boolean: + writer.WriteString(L"bool"); + break; + case GuiRpPrimitiveTypes::Integer: + writer.WriteString(L"::vl::vint"); + break; + case GuiRpPrimitiveTypes::Float: + writer.WriteString(L"float"); + break; + case GuiRpPrimitiveTypes::Double: + writer.WriteString(L"double"); + break; + case GuiRpPrimitiveTypes::String: + writer.WriteString(L"::vl::WString"); + break; + case GuiRpPrimitiveTypes::Char: + writer.WriteString(L"wchar_t"); + break; + case GuiRpPrimitiveTypes::Key: + writer.WriteString(L"::vl::presentation::VKEY"); + break; + default: + CHECK_FAIL(L"Unrecognized type"); + } + } + + static WString GetCppType(const WString& type, Ptr symbols, GuiRpCppConfig& config) + { + vint index = symbols->cppMapping.Keys().IndexOf(type); + if (index == -1) + { + return config.cppNamespace + L"::" + type; + } + else + { + return symbols->cppMapping.Values()[index]; + } + } + + void Visit(GuiRpReferenceType* node) override + { + writer.WriteString(GetCppType(node->name.value, symbols, config)); + } + + void Visit(GuiRpArrayType* node) override + { + writer.WriteString(L"::vl::Ptr<::vl::collections::List<"); + node->element->Accept(this); + writer.WriteString(L">>"); + } + }; + + void GenerateSerializerFunctionHeader(const WString& type, bool semicolon, stream::TextWriter& writer) + { + writer.WriteString(L"\ttemplate<> vl::Ptr ConvertCustomTypeToJson<" + type + L">(const " + type + L" & value)"); + writer.WriteLine(semicolon ? L";" : L""); + } + + void GenerateDeserializerFunctionHeader(const WString& type, bool semicolon, stream::TextWriter& writer) + { + writer.WriteString(L"\ttemplate<> void ConvertJsonToCustomType<" + type + L">(vl::Ptr node, " + type + L"& value)"); + writer.WriteLine(semicolon ? L";" : L""); + } + + void GenerateRemoteProtocolHeaderFile(Ptr schema, Ptr symbols, GuiRpCppConfig& config, stream::TextWriter& writer) + { + writer.WriteLine(L"/***********************************************************************"); + writer.WriteLine(L"This file is generated by : Vczh GacUI Remote Protocol Generator"); + writer.WriteLine(L"Licensed under https ://github.com/vczh-libraries/License"); + writer.WriteLine(L"***********************************************************************/"); + writer.WriteLine(L""); + writer.WriteLine(L"#ifndef " + config.headerGuard); + writer.WriteLine(L"#define " + config.headerGuard); + writer.WriteLine(L""); + writer.WriteLine(L"#include \"" + config.headerInclude + L"\""); + writer.WriteLine(L""); + writer.WriteLine(L"namespace " + config.cppNamespace); + writer.WriteLine(L"{"); + + GuiRpPrintTypeVisitor printTypeVisitor(symbols, config, writer); + + for (auto enumDecl : From(schema->declarations).FindType()) + { + if (!symbols->cppMapping.Keys().Contains(enumDecl->name.value)) + { + writer.WriteLine(L"\tenum class " + enumDecl->name.value); + writer.WriteLine(L"\t{"); + for (auto member : enumDecl->members) + { + writer.WriteLine(L"\t\t" + member->name.value + L","); + } + writer.WriteLine(L"\t};"); + writer.WriteLine(L""); + } + } + + for (auto structDecl : From(schema->declarations).FindType()) + { + if (!symbols->cppMapping.Keys().Contains(structDecl->name.value)) + { + writer.WriteLine(L"\tstruct " + structDecl->name.value); + writer.WriteLine(L"\t{"); + for (auto member : structDecl->members) + { + writer.WriteString(L"\t\t"); + member->type->Accept(&printTypeVisitor); + writer.WriteLine(L" " + member->name.value + L";"); + } + writer.WriteLine(L"\t};"); + writer.WriteLine(L""); + } + } + + for (auto enumDecl : From(schema->declarations).FindType()) + { + GenerateSerializerFunctionHeader(GuiRpPrintTypeVisitor::GetCppType(enumDecl->name.value, symbols, config), true, writer); + } + for (auto structDecl : From(schema->declarations).FindType()) + { + GenerateSerializerFunctionHeader(GuiRpPrintTypeVisitor::GetCppType(structDecl->name.value, symbols, config), true, writer); + } + writer.WriteLine(L""); + + for (auto enumDecl : From(schema->declarations).FindType()) + { + GenerateDeserializerFunctionHeader(GuiRpPrintTypeVisitor::GetCppType(enumDecl->name.value, symbols, config), true, writer); + } + for (auto structDecl : From(schema->declarations).FindType()) + { + GenerateDeserializerFunctionHeader(GuiRpPrintTypeVisitor::GetCppType(structDecl->name.value, symbols, config), true, writer); + } + writer.WriteLine(L""); + + writer.WriteLine(L"#define " + config.builderMacroPrefix + L"_MESSAGES(HANDLER)\\"); + for (auto messageDecl : From(schema->declarations).FindType()) + { + writer.WriteString(L"\tHANDLER(" + messageDecl->name.value); + + writer.WriteString(L", "); + if (messageDecl->request) + { + messageDecl->request->type->Accept(&printTypeVisitor); + } + else + { + writer.WriteString(L"void"); + } + + writer.WriteString(L", "); + if (messageDecl->response) + { + messageDecl->response->type->Accept(&printTypeVisitor); + } + else + { + writer.WriteString(L"void"); + } + + writer.WriteString(messageDecl->request ? L", REQ" : L", NOREQ"); + writer.WriteString(messageDecl->response ? L", RES" : L", NORES"); + writer.WriteString(symbols->dropRepeatDeclNames.Contains(messageDecl->name.value) ? L", DROPREP" : L", NODROP"); + writer.WriteLine(L")\\"); + } + writer.WriteLine(L""); + + writer.WriteLine(L"#define " + config.builderMacroPrefix + L"_EVENTS(HANDLER)\\"); + for (auto eventDecl : From(schema->declarations).FindType()) + { + writer.WriteString(L"\tHANDLER(" + eventDecl->name.value); + + writer.WriteString(L", "); + if (eventDecl->request) + { + eventDecl->request->type->Accept(&printTypeVisitor); + } + else + { + writer.WriteString(L"void"); + } + + writer.WriteString(eventDecl->request ? L", REQ" : L", NOREQ"); + writer.WriteString( + symbols->dropRepeatDeclNames.Contains(eventDecl->name.value) ? L", DROPREP" : + symbols->dropConsecutiveDeclNames.Contains(eventDecl->name.value) ? L", DROPCON" : + L", NODROP"); + writer.WriteLine(L")\\"); + } + writer.WriteLine(L""); + + writer.WriteLine(L"}"); + writer.WriteLine(L""); + writer.WriteLine(L"#endif"); + } + +/*********************************************************************** +GenerateRemoteProtocolCppFile +***********************************************************************/ + + void GenerateEnumSerializerFunctionImpl(Ptr enumDecl, Ptr symbols, GuiRpCppConfig& config, stream::TextWriter& writer) + { + WString cppName = GuiRpPrintTypeVisitor::GetCppType(enumDecl->name.value, symbols, config); + GenerateSerializerFunctionHeader(cppName, false, writer); + writer.WriteLine(L"\t{"); + writer.WriteLine(L"#define ERROR_MESSAGE_PREFIX L\"vl::presentation::remoteprotocol::ConvertCustomTypeToJson<" + cppName + L">(const " + cppName + L"&)#\""); + writer.WriteLine(L"\t\tauto node = Ptr(new glr::json::JsonString);"); + writer.WriteLine(L"\t\tswitch (value)"); + writer.WriteLine(L"\t\t{"); + for (auto member : enumDecl->members) + { + writer.WriteLine(L"\t\tcase " + cppName + L"::" + member->name.value + L": node->content.value = L\"" + member->name.value + L"\"; break;"); + } + writer.WriteLine(L"\t\tdefault: CHECK_FAIL(ERROR_MESSAGE_PREFIX L\"Unsupported enum value.\");"); + writer.WriteLine(L"\t\t}"); + writer.WriteLine(L"\t\treturn node;"); + writer.WriteLine(L"#undef ERROR_MESSAGE_PREFIX"); + writer.WriteLine(L"\t}"); + writer.WriteLine(L""); + } + + void GenerateStructSerializerFunctionImpl(Ptr structDecl, Ptr symbols, GuiRpCppConfig& config, stream::TextWriter& writer) + { + WString cppName = GuiRpPrintTypeVisitor::GetCppType(structDecl->name.value, symbols, config); + GenerateSerializerFunctionHeader(cppName, false, writer); + writer.WriteLine(L"\t{"); + writer.WriteLine(L"\t\tauto node = Ptr(new glr::json::JsonObject);"); + for (auto member : structDecl->members) + { + writer.WriteLine(L"\t\tConvertCustomTypeToJsonField(node, L\"" + member->name.value + L"\", value." + member->name.value + L");"); + } + writer.WriteLine(L"\t\treturn node;"); + writer.WriteLine(L"\t}"); + writer.WriteLine(L""); + } + + void GenerateEnumDeserializerFunctionImpl(Ptr enumDecl, Ptr symbols, GuiRpCppConfig& config, stream::TextWriter& writer) + { + WString cppName = GuiRpPrintTypeVisitor::GetCppType(enumDecl->name.value, symbols, config); + GenerateDeserializerFunctionHeader(cppName, false, writer); + writer.WriteLine(L"\t{"); + writer.WriteLine(L"#define ERROR_MESSAGE_PREFIX L\"vl::presentation::remoteprotocol::ConvertJsonToCustomType<" + cppName + L">(Ptr, " + cppName + L"&)#\""); + writer.WriteLine(L"\t\tauto jsonNode = node.Cast();"); + writer.WriteLine(L"\t\tCHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L\"Json node does not match the expected type.\");"); + for (auto member : enumDecl->members) + { + writer.WriteLine(L"\t\tif (jsonNode->content.value == L\"" + member->name.value + L"\") value = " + cppName + L"::" + member->name.value + L"; else"); + } + writer.WriteLine(L"\t\tCHECK_FAIL(ERROR_MESSAGE_PREFIX L\"Unsupported enum value.\");"); + writer.WriteLine(L"#undef ERROR_MESSAGE_PREFIX"); + writer.WriteLine(L"\t}"); + writer.WriteLine(L""); + } + + void GenerateStructDeserializerFunctionImpl(Ptr structDecl, Ptr symbols, GuiRpCppConfig& config, stream::TextWriter& writer) + { + WString cppName = GuiRpPrintTypeVisitor::GetCppType(structDecl->name.value, symbols, config); + GenerateDeserializerFunctionHeader(cppName, false, writer); + writer.WriteLine(L"\t{"); + writer.WriteLine(L"#define ERROR_MESSAGE_PREFIX L\"vl::presentation::remoteprotocol::ConvertJsonToCustomType<" + cppName + L">(Ptr, " + cppName + L"&)#\""); + writer.WriteLine(L"\t\tauto jsonNode = node.Cast();"); + writer.WriteLine(L"\t\tCHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L\"Json node does not match the expected type.\");"); + writer.WriteLine(L"\t\tfor (auto field : jsonNode->fields)"); + writer.WriteLine(L"\t\t{"); + for (auto member : structDecl->members) + { + writer.WriteLine(L"\t\t\tif (field->name.value == L\"" + member->name.value + L"\") ConvertJsonToCustomType(field->value, value." + member->name.value + L"); else"); + } + writer.WriteLine(L"\t\t\tCHECK_FAIL(ERROR_MESSAGE_PREFIX L\"Unsupported struct member.\");"); + writer.WriteLine(L"\t\t}"); + writer.WriteLine(L"#undef ERROR_MESSAGE_PREFIX"); + writer.WriteLine(L"\t}"); + writer.WriteLine(L""); + } + + void GenerateRemoteProtocolCppFile(Ptr schema, Ptr symbols, GuiRpCppConfig& config, stream::TextWriter& writer) + { + writer.WriteLine(L"/***********************************************************************"); + writer.WriteLine(L"This file is generated by : Vczh GacUI Remote Protocol Generator"); + writer.WriteLine(L"Licensed under https ://github.com/vczh-libraries/License"); + writer.WriteLine(L"***********************************************************************/"); + writer.WriteLine(L""); + writer.WriteLine(L"#include \"" + config.headerFileName + L"\""); + writer.WriteLine(L""); + writer.WriteLine(L"namespace " + config.cppNamespace); + writer.WriteLine(L"{"); + + for (auto enumDecl : From(schema->declarations).FindType()) + { + GenerateEnumSerializerFunctionImpl(enumDecl, symbols, config, writer); + } + for (auto structDecl : From(schema->declarations).FindType()) + { + GenerateStructSerializerFunctionImpl(structDecl, symbols, config, writer); + } + + for (auto enumDecl : From(schema->declarations).FindType()) + { + GenerateEnumDeserializerFunctionImpl(enumDecl, symbols, config, writer); + } + for (auto structDecl : From(schema->declarations).FindType()) + { + GenerateStructDeserializerFunctionImpl(structDecl, symbols, config, writer); + } + writer.WriteLine(L"}"); + } +} + + +/*********************************************************************** +.\REMOTEPROTOCOL\GENERATED\GUIREMOTEPROTOCOLAST.CPP +***********************************************************************/ +/*********************************************************************** +This file is generated by: Vczh Parser Generator +From parser definition:Ast +Licensed under https://github.com/vczh-libraries/License +***********************************************************************/ + + +namespace vl::presentation::remoteprotocol +{ +/*********************************************************************** +Visitor Pattern Implementation +***********************************************************************/ + + void GuiRpPrimitiveType::Accept(GuiRpType::IVisitor* visitor) + { + visitor->Visit(this); + } + + void GuiRpReferenceType::Accept(GuiRpType::IVisitor* visitor) + { + visitor->Visit(this); + } + + void GuiRpArrayType::Accept(GuiRpType::IVisitor* visitor) + { + visitor->Visit(this); + } + + void GuiRpEnumDecl::Accept(GuiRpDeclaration::IVisitor* visitor) + { + visitor->Visit(this); + } + + void GuiRpStructDecl::Accept(GuiRpDeclaration::IVisitor* visitor) + { + visitor->Visit(this); + } + + void GuiRpMessageDecl::Accept(GuiRpDeclaration::IVisitor* visitor) + { + visitor->Visit(this); + } + + void GuiRpEventDecl::Accept(GuiRpDeclaration::IVisitor* visitor) + { + visitor->Visit(this); + } +} +namespace vl::reflection::description +{ +#ifndef VCZH_DEBUG_NO_REFLECTION + + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpType, presentation::remoteprotocol::GuiRpType) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpType::IVisitor, presentation::remoteprotocol::GuiRpType::IVisitor) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpPrimitiveTypes, presentation::remoteprotocol::GuiRpPrimitiveTypes) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpPrimitiveType, presentation::remoteprotocol::GuiRpPrimitiveType) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpReferenceType, presentation::remoteprotocol::GuiRpReferenceType) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpArrayType, presentation::remoteprotocol::GuiRpArrayType) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpAttribute, presentation::remoteprotocol::GuiRpAttribute) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpDeclaration, presentation::remoteprotocol::GuiRpDeclaration) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpDeclaration::IVisitor, presentation::remoteprotocol::GuiRpDeclaration::IVisitor) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpEnumMember, presentation::remoteprotocol::GuiRpEnumMember) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpEnumDecl, presentation::remoteprotocol::GuiRpEnumDecl) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpStructMember, presentation::remoteprotocol::GuiRpStructMember) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpStructDecl, presentation::remoteprotocol::GuiRpStructDecl) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpMessageRequest, presentation::remoteprotocol::GuiRpMessageRequest) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpMessageResponse, presentation::remoteprotocol::GuiRpMessageResponse) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpMessageDecl, presentation::remoteprotocol::GuiRpMessageDecl) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpEventRequest, presentation::remoteprotocol::GuiRpEventRequest) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpEventDecl, presentation::remoteprotocol::GuiRpEventDecl) + IMPL_TYPE_INFO_RENAME(vl::presentation::remoteprotocol::GuiRpSchema, presentation::remoteprotocol::GuiRpSchema) + +#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA + + BEGIN_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpType) + CLASS_MEMBER_BASE(vl::glr::ParsingAstBase) + + END_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpType) + + BEGIN_ENUM_ITEM(vl::presentation::remoteprotocol::GuiRpPrimitiveTypes) + ENUM_ITEM_NAMESPACE(vl::presentation::remoteprotocol::GuiRpPrimitiveTypes) + ENUM_NAMESPACE_ITEM(Boolean) + ENUM_NAMESPACE_ITEM(Integer) + ENUM_NAMESPACE_ITEM(Float) + ENUM_NAMESPACE_ITEM(Double) + ENUM_NAMESPACE_ITEM(String) + ENUM_NAMESPACE_ITEM(Char) + ENUM_NAMESPACE_ITEM(Key) + END_ENUM_ITEM(vl::presentation::remoteprotocol::GuiRpPrimitiveTypes) + + BEGIN_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpPrimitiveType) + CLASS_MEMBER_BASE(vl::presentation::remoteprotocol::GuiRpType) + + CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) + + CLASS_MEMBER_FIELD(type) + END_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpPrimitiveType) + + BEGIN_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpReferenceType) + CLASS_MEMBER_BASE(vl::presentation::remoteprotocol::GuiRpType) + + CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) + + CLASS_MEMBER_FIELD(name) + END_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpReferenceType) + + BEGIN_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpArrayType) + CLASS_MEMBER_BASE(vl::presentation::remoteprotocol::GuiRpType) + + CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) + + CLASS_MEMBER_FIELD(element) + END_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpArrayType) + + BEGIN_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpAttribute) + CLASS_MEMBER_BASE(vl::glr::ParsingAstBase) + + CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) + + CLASS_MEMBER_FIELD(name) + CLASS_MEMBER_FIELD(cppType) + END_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpAttribute) + + BEGIN_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpDeclaration) + CLASS_MEMBER_BASE(vl::glr::ParsingAstBase) + + CLASS_MEMBER_FIELD(attributes) + CLASS_MEMBER_FIELD(name) + END_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpDeclaration) + + BEGIN_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpEnumMember) + CLASS_MEMBER_BASE(vl::glr::ParsingAstBase) + + CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) + + CLASS_MEMBER_FIELD(name) + END_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpEnumMember) + + BEGIN_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpEnumDecl) + CLASS_MEMBER_BASE(vl::presentation::remoteprotocol::GuiRpDeclaration) + + CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) + + CLASS_MEMBER_FIELD(members) + END_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpEnumDecl) + + BEGIN_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpStructMember) + CLASS_MEMBER_BASE(vl::glr::ParsingAstBase) + + CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) + + CLASS_MEMBER_FIELD(name) + CLASS_MEMBER_FIELD(type) + END_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpStructMember) + + BEGIN_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpStructDecl) + CLASS_MEMBER_BASE(vl::presentation::remoteprotocol::GuiRpDeclaration) + + CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) + + CLASS_MEMBER_FIELD(members) + END_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpStructDecl) + + BEGIN_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpMessageRequest) + CLASS_MEMBER_BASE(vl::glr::ParsingAstBase) + + CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) + + CLASS_MEMBER_FIELD(type) + END_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpMessageRequest) + + BEGIN_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpMessageResponse) + CLASS_MEMBER_BASE(vl::glr::ParsingAstBase) + + CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) + + CLASS_MEMBER_FIELD(type) + END_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpMessageResponse) + + BEGIN_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpMessageDecl) + CLASS_MEMBER_BASE(vl::presentation::remoteprotocol::GuiRpDeclaration) + + CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) + + CLASS_MEMBER_FIELD(request) + CLASS_MEMBER_FIELD(response) + END_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpMessageDecl) + + BEGIN_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpEventRequest) + CLASS_MEMBER_BASE(vl::glr::ParsingAstBase) + + CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) + + CLASS_MEMBER_FIELD(type) + END_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpEventRequest) + + BEGIN_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpEventDecl) + CLASS_MEMBER_BASE(vl::presentation::remoteprotocol::GuiRpDeclaration) + + CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) + + CLASS_MEMBER_FIELD(request) + END_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpEventDecl) + + BEGIN_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpSchema) + CLASS_MEMBER_BASE(vl::glr::ParsingAstBase) + + CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) + + CLASS_MEMBER_FIELD(declarations) + END_CLASS_MEMBER(vl::presentation::remoteprotocol::GuiRpSchema) + + BEGIN_INTERFACE_MEMBER(vl::presentation::remoteprotocol::GuiRpType::IVisitor) + CLASS_MEMBER_METHOD_OVERLOAD(Visit, {L"node"}, void(vl::presentation::remoteprotocol::GuiRpType::IVisitor::*)(vl::presentation::remoteprotocol::GuiRpPrimitiveType* node)) + CLASS_MEMBER_METHOD_OVERLOAD(Visit, {L"node"}, void(vl::presentation::remoteprotocol::GuiRpType::IVisitor::*)(vl::presentation::remoteprotocol::GuiRpReferenceType* node)) + CLASS_MEMBER_METHOD_OVERLOAD(Visit, {L"node"}, void(vl::presentation::remoteprotocol::GuiRpType::IVisitor::*)(vl::presentation::remoteprotocol::GuiRpArrayType* node)) + END_INTERFACE_MEMBER(vl::presentation::remoteprotocol::GuiRpType) + + BEGIN_INTERFACE_MEMBER(vl::presentation::remoteprotocol::GuiRpDeclaration::IVisitor) + CLASS_MEMBER_METHOD_OVERLOAD(Visit, {L"node"}, void(vl::presentation::remoteprotocol::GuiRpDeclaration::IVisitor::*)(vl::presentation::remoteprotocol::GuiRpEnumDecl* node)) + CLASS_MEMBER_METHOD_OVERLOAD(Visit, {L"node"}, void(vl::presentation::remoteprotocol::GuiRpDeclaration::IVisitor::*)(vl::presentation::remoteprotocol::GuiRpStructDecl* node)) + CLASS_MEMBER_METHOD_OVERLOAD(Visit, {L"node"}, void(vl::presentation::remoteprotocol::GuiRpDeclaration::IVisitor::*)(vl::presentation::remoteprotocol::GuiRpMessageDecl* node)) + CLASS_MEMBER_METHOD_OVERLOAD(Visit, {L"node"}, void(vl::presentation::remoteprotocol::GuiRpDeclaration::IVisitor::*)(vl::presentation::remoteprotocol::GuiRpEventDecl* node)) + END_INTERFACE_MEMBER(vl::presentation::remoteprotocol::GuiRpDeclaration) + +#endif + +#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA + class GuiRemoteProtocolAstTypeLoader : public vl::Object, public ITypeLoader + { + public: + void Load(ITypeManager* manager) + { + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpType) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpType::IVisitor) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpPrimitiveTypes) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpPrimitiveType) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpReferenceType) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpArrayType) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpAttribute) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpDeclaration) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpDeclaration::IVisitor) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpEnumMember) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpEnumDecl) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpStructMember) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpStructDecl) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpMessageRequest) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpMessageResponse) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpMessageDecl) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpEventRequest) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpEventDecl) + ADD_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpSchema) + } + + void Unload(ITypeManager* manager) + { + } + }; +#endif +#endif + + bool GuiRemoteProtocolAstLoadTypes() + { +#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA + if (auto manager = GetGlobalTypeManager()) + { + auto loader = Ptr(new GuiRemoteProtocolAstTypeLoader); + return manager->AddTypeLoader(loader); + } +#endif + return false; + } +} + + +/*********************************************************************** +.\REMOTEPROTOCOL\GENERATED\GUIREMOTEPROTOCOLAST_JSON.CPP +***********************************************************************/ +/*********************************************************************** +This file is generated by: Vczh Parser Generator +From parser definition:Ast +Licensed under https://github.com/vczh-libraries/License +***********************************************************************/ + + +namespace vl::presentation::remoteprotocol::json_visitor +{ + void AstVisitor::PrintFields(GuiRpArrayType* node) + { + BeginField(L"element"); + Print(node->element.Obj()); + EndField(); + } + void AstVisitor::PrintFields(GuiRpAttribute* node) + { + BeginField(L"cppType"); + WriteToken(node->cppType); + EndField(); + BeginField(L"name"); + WriteToken(node->name); + EndField(); + } + void AstVisitor::PrintFields(GuiRpDeclaration* node) + { + BeginField(L"attributes"); + BeginArray(); + for (auto&& listItem : node->attributes) + { + BeginArrayItem(); + Print(listItem.Obj()); + EndArrayItem(); + } + EndArray(); + EndField(); + BeginField(L"name"); + WriteToken(node->name); + EndField(); + } + void AstVisitor::PrintFields(GuiRpEnumDecl* node) + { + BeginField(L"members"); + BeginArray(); + for (auto&& listItem : node->members) + { + BeginArrayItem(); + Print(listItem.Obj()); + EndArrayItem(); + } + EndArray(); + EndField(); + } + void AstVisitor::PrintFields(GuiRpEnumMember* node) + { + BeginField(L"name"); + WriteToken(node->name); + EndField(); + } + void AstVisitor::PrintFields(GuiRpEventDecl* node) + { + BeginField(L"request"); + Print(node->request.Obj()); + EndField(); + } + void AstVisitor::PrintFields(GuiRpEventRequest* node) + { + BeginField(L"type"); + Print(node->type.Obj()); + EndField(); + } + void AstVisitor::PrintFields(GuiRpMessageDecl* node) + { + BeginField(L"request"); + Print(node->request.Obj()); + EndField(); + BeginField(L"response"); + Print(node->response.Obj()); + EndField(); + } + void AstVisitor::PrintFields(GuiRpMessageRequest* node) + { + BeginField(L"type"); + Print(node->type.Obj()); + EndField(); + } + void AstVisitor::PrintFields(GuiRpMessageResponse* node) + { + BeginField(L"type"); + Print(node->type.Obj()); + EndField(); + } + void AstVisitor::PrintFields(GuiRpPrimitiveType* node) + { + BeginField(L"type"); + switch (node->type) + { + case vl::presentation::remoteprotocol::GuiRpPrimitiveTypes::Boolean: + WriteString(L"Boolean"); + break; + case vl::presentation::remoteprotocol::GuiRpPrimitiveTypes::Char: + WriteString(L"Char"); + break; + case vl::presentation::remoteprotocol::GuiRpPrimitiveTypes::Double: + WriteString(L"Double"); + break; + case vl::presentation::remoteprotocol::GuiRpPrimitiveTypes::Float: + WriteString(L"Float"); + break; + case vl::presentation::remoteprotocol::GuiRpPrimitiveTypes::Integer: + WriteString(L"Integer"); + break; + case vl::presentation::remoteprotocol::GuiRpPrimitiveTypes::Key: + WriteString(L"Key"); + break; + case vl::presentation::remoteprotocol::GuiRpPrimitiveTypes::String: + WriteString(L"String"); + break; + default: + WriteNull(); + } + EndField(); + } + void AstVisitor::PrintFields(GuiRpReferenceType* node) + { + BeginField(L"name"); + WriteToken(node->name); + EndField(); + } + void AstVisitor::PrintFields(GuiRpSchema* node) + { + BeginField(L"declarations"); + BeginArray(); + for (auto&& listItem : node->declarations) + { + BeginArrayItem(); + Print(listItem.Obj()); + EndArrayItem(); + } + EndArray(); + EndField(); + } + void AstVisitor::PrintFields(GuiRpStructDecl* node) + { + BeginField(L"members"); + BeginArray(); + for (auto&& listItem : node->members) + { + BeginArrayItem(); + Print(listItem.Obj()); + EndArrayItem(); + } + EndArray(); + EndField(); + } + void AstVisitor::PrintFields(GuiRpStructMember* node) + { + BeginField(L"name"); + WriteToken(node->name); + EndField(); + BeginField(L"type"); + Print(node->type.Obj()); + EndField(); + } + void AstVisitor::PrintFields(GuiRpType* node) + { + } + + void AstVisitor::Visit(GuiRpPrimitiveType* node) + { + if (!node) + { + WriteNull(); + return; + } + BeginObject(); + WriteType(L"PrimitiveType", node); + PrintFields(static_cast(node)); + PrintFields(static_cast(node)); + EndObject(); + } + + void AstVisitor::Visit(GuiRpReferenceType* node) + { + if (!node) + { + WriteNull(); + return; + } + BeginObject(); + WriteType(L"ReferenceType", node); + PrintFields(static_cast(node)); + PrintFields(static_cast(node)); + EndObject(); + } + + void AstVisitor::Visit(GuiRpArrayType* node) + { + if (!node) + { + WriteNull(); + return; + } + BeginObject(); + WriteType(L"ArrayType", node); + PrintFields(static_cast(node)); + PrintFields(static_cast(node)); + EndObject(); + } + + void AstVisitor::Visit(GuiRpEnumDecl* node) + { + if (!node) + { + WriteNull(); + return; + } + BeginObject(); + WriteType(L"EnumDecl", node); + PrintFields(static_cast(node)); + PrintFields(static_cast(node)); + EndObject(); + } + + void AstVisitor::Visit(GuiRpStructDecl* node) + { + if (!node) + { + WriteNull(); + return; + } + BeginObject(); + WriteType(L"StructDecl", node); + PrintFields(static_cast(node)); + PrintFields(static_cast(node)); + EndObject(); + } + + void AstVisitor::Visit(GuiRpMessageDecl* node) + { + if (!node) + { + WriteNull(); + return; + } + BeginObject(); + WriteType(L"MessageDecl", node); + PrintFields(static_cast(node)); + PrintFields(static_cast(node)); + EndObject(); + } + + void AstVisitor::Visit(GuiRpEventDecl* node) + { + if (!node) + { + WriteNull(); + return; + } + BeginObject(); + WriteType(L"EventDecl", node); + PrintFields(static_cast(node)); + PrintFields(static_cast(node)); + EndObject(); + } + + AstVisitor::AstVisitor(vl::stream::StreamWriter& _writer) + : vl::glr::JsonVisitorBase(_writer) + { + } + + void AstVisitor::Print(GuiRpType* node) + { + if (!node) + { + WriteNull(); + return; + } + node->Accept(static_cast(this)); + } + + void AstVisitor::Print(GuiRpDeclaration* node) + { + if (!node) + { + WriteNull(); + return; + } + node->Accept(static_cast(this)); + } + + void AstVisitor::Print(GuiRpAttribute* node) + { + if (!node) + { + WriteNull(); + return; + } + BeginObject(); + WriteType(L"Attribute", node); + PrintFields(static_cast(node)); + EndObject(); + } + + void AstVisitor::Print(GuiRpEnumMember* node) + { + if (!node) + { + WriteNull(); + return; + } + BeginObject(); + WriteType(L"EnumMember", node); + PrintFields(static_cast(node)); + EndObject(); + } + + void AstVisitor::Print(GuiRpStructMember* node) + { + if (!node) + { + WriteNull(); + return; + } + BeginObject(); + WriteType(L"StructMember", node); + PrintFields(static_cast(node)); + EndObject(); + } + + void AstVisitor::Print(GuiRpMessageRequest* node) + { + if (!node) + { + WriteNull(); + return; + } + BeginObject(); + WriteType(L"MessageRequest", node); + PrintFields(static_cast(node)); + EndObject(); + } + + void AstVisitor::Print(GuiRpMessageResponse* node) + { + if (!node) + { + WriteNull(); + return; + } + BeginObject(); + WriteType(L"MessageResponse", node); + PrintFields(static_cast(node)); + EndObject(); + } + + void AstVisitor::Print(GuiRpEventRequest* node) + { + if (!node) + { + WriteNull(); + return; + } + BeginObject(); + WriteType(L"EventRequest", node); + PrintFields(static_cast(node)); + EndObject(); + } + + void AstVisitor::Print(GuiRpSchema* node) + { + if (!node) + { + WriteNull(); + return; + } + BeginObject(); + WriteType(L"Schema", node); + PrintFields(static_cast(node)); + EndObject(); + } + +} + + +/*********************************************************************** +.\REMOTEPROTOCOL\GENERATED\GUIREMOTEPROTOCOLPARSER.CPP +***********************************************************************/ +/*********************************************************************** +This file is generated by: Vczh Parser Generator +From parser definition:GuiRemoteProtocol +Licensed under https://github.com/vczh-libraries/License +***********************************************************************/ + + +namespace vl::presentation::remoteprotocol +{ + void GuiRemoteProtocolParserData(vl::stream::IStream& outputStream) + { + static const vl::vint dataLength = 5216; // 69320 bytes before compressing + static const vl::vint dataBlock = 256; + static const vl::vint dataRemain = 96; + static const vl::vint dataSolidRows = 20; + static const vl::vint dataRows = 21; + static const char* compressed[] = { + "\xC8\x0E\x01\x00\x58\x14\x00\x00\x1B\x00\x01\x82\x80\x0F\x03\x82\x81\x82\x06\x89\x82\x8D\x0A\x80\x0A\x84\x0C\x0A\x9C\x0A\x83\x1A\x82\x16\x85\x18\x0A\xB7\x0A\x9D\x1A\x85\x22\x85\x25\x0A\xD2\x0A\x98\x2A\x84\x2E\x84\x70\x0A\x09\xBF\x6B\x9C\x93\x96\x84\x00\x2D\xAD\xAF\x91\x9C\x93\x98\x9B\x7F\x36\xB4\xB9\x91\x9B\x9A\x9A\x85\x9B\x38\xBF\xB7\x8F\x9F\x91\x02\x84\xA3\x09\xC8\x86\x82\x07\xA2\x87\x01\xA6\x09\x84\x10\xA6\x85\x03\xAB\x80\x03\x56\x82\x80\xBD\x95\x9A\x87\x03\xAC\x01\xDB\x82\xBA\x93\xB4\x9D\xB2\x9F\x2A\xC3\xA7\xBD\xA9\xB4\xB1\xB6\xB3\x6F\xE8\x86\x82\xB1\xBC\xB7\xB8\xB5\x75\xAE\xAB\xBA\xB9\xB9\xA1\xBE\xAE\x7C\xF7\xAE\xA2\xC0\xBC\xC2\xB9\x81\x74\x86\xF6\xA8\xC8\xBA\xC5\xC0\xC6\x83\x90\xC5\xD2\xC7\xC2\xAD\xC6\xCA\x8B\x96\xD1\xDA\xC3\xCC\xCD\xCB\xB0\x97\x9E\xD9\xC0\xDB\xCC\xD1\xCE\xD3\x9F\xB0\xA1\xC8\xD3\xD0\x00\x04\xB0\x00\x09\x30\xC9\xC8\xCF\xC6\xD0\xDB\xAC\xB8\xEA\xC5\xDB\xDF\xD1\xDF\xD4\xB4\xB7\xFE\xAE\xC3\xE5\xD9\xE2\xE1\x80\xC7\xF9\xCA\xEF\xDD\xD5\xE1\xE5\xC9\xD1\xFB\xAC\xEF\xE5\xE6\xDD\xEA\xD8\xAB\xD6\xF4", + "\xEA\xE9\x95\xA4\x85\x0B\x33\xDA\xF9\xEC\xDC\xF2\xDE\xF3\xC0\xE3\xEA\xE5\xFB\xF7\xF1\xF7\xF4\xEC\xF1\xEE\xF2\xF0\xFB\xFA\xFB\xFA\xF8\xCE\xEF\xFA\xFC\xDC\x04\xD8\x86\xDF\x7F\x53\x76\x74\x02\x85\x84\x70\x81\x07\x83\x8A\x82\x81\xC6\x48\x8D\x83\x82\x09\x8C\x88\x70\x84\x0F\x92\x80\x74\x85\x13\x96\x8B\x76\x83\x02\x4E\x00\x6C\x42\x06\x4A\x55\x85\x84\x24\xA3\x86\x89\x86\x25\xA8\x87\x8B\x85\x1A\xA8\x7C\x7F\x7D\x2F\xB9\x77\x77\x7E\x33\xB4\x71\x8F\x8D\x35\xB0\x89\x8E\x8C\xCC\x4E\x41\x82\x41\x11\x22\x76\x8F\x8E\x38\x9C\x73\x92\x91\x3A\x88\x9C\x8C\x87\x2C\xA9\x8D\x93\x8A\x1B\x98\x8F\x92\x8A\x54\x93\x96\x95\x94\x2D\xB4\x8A\x91\x6B\x12\x30\x63\x06\x90\x49\x8C\x98\x96\x93\x63\x90\x9E\x88\x91\x68\x9B\x99\x9A\x98\x67\xAA\x9E\x98\x9B\x5A\xB0\x97\x92\x9C\x61\x8A\x44\x04\x6C\x15\x20\x9B\x92\x94\x65\x95\x9D\x9F\x95\x6D\xB4\x9B\x9D\x96\x73\xBC\x91\xA2\xA1\x71\x88\xA5\xA0\xA1\x75\x89\x46\x04\x6C\x17\x3A\x95\x92\xA0\x93\x8A\xAD\xA0\x99\x87\x8C\xA3\xA0\xA6\x89\x9A\xA5\xA6\xA7\x6B\x96\xAB\xA4\x94\x10\x7F\x83\x41\x06\x92\xA1\xA0\xAB\x9B", + "\xA2\x9F\xAC\xA7\xA2\xAF\x97\xA6\x99\xA7\xB1\xA3\xAE\x9D\xA6\xB5\xAE\xA3\xAC\xAC\xBB\xB2\xA7\xAC\xAD\xBD\xB6\xA0\xA0\xB0\xBF\xBC\xA5\xB2\xAF\xC3\xBC\x6A\x05\xAA\xAC\xAB\xA4\xA6\xAA\xB9\x90\xB1\xB2\xAE\xC7\x82\xBF\x9F\xB5\xB8\x93\xB2\xB5\xB5\xD4\x97\x90\x42\xA9\xDC\x9B\xB9\xB0\xB2\xD8\x84\xB3\xBA\xB5\xD9\xA1\xBD\xB1\xB4\xEB\x9A\xBD\xBA\x40\x12\x60\xB7\xB9\xB7\xE5\x86\xB3\xBE\xB8\xF5\xA4\xB9\xBB\xBD\xEF\xBC\xBF\xB1\xBF\xF9\xA8\xB6\xB9\xC0\xF4\xBB\xB4\xC0\xBE\x06\xC9\xC3\xC1\x07\xCC\xBF\xBE\xC1\xAB\x08\xC3\xCA\xC2\xBD\x07\xC0\xC3\xC6\xBE\x12\xD9\xC4\xC7\xC5\x02\xDB\xCA\xC4\xC6\x1E\xE1\xC0\xCB\xC8\x1D\xE4\xBE\x05\xC3\x10\xD6\xCF\xC5\xC9\x2C\xC5\xCB\xCA\xCB\x22\xED\xC1\xC5\xCC\x30\xE4\xC5\xCE\xCC\x2A\xF4\xC3\xCE\xCD\x3B\xF8\xCF\xC2\xB3\x29\xFF\xC6\x43\x07\x28\xC0\xD6\xD0\xBB\x42\xEE\xB9\xD2\xBA\x4B\xFE\xB1\xD3\xD3\x47\xCA\xD0\xD4\xD2\x53\xC3\x40\x08\x6C\x21\x05\xD4\xD5\xD4\x4C\xD5\xDD\xD4\xD7\x4E\xE0\xD5\xC5\xD3\x00\x22\x0A\xD6\xD4\x62\xDC\xC7\xCF\xDA\x3D\xEC\xD9\xCC\xCF\x6F\xFE\xCE\xD5\xD8\x5B\xF5\xD8\xDA\x41\x14", + "\x72\xB3\xDB\xDC\x7B\xC9\x44\x0B\xD9\x5F\xF6\xD1\xE3\xDD\x84\xC3\xE6\xE0\xDD\x85\xC8\xE7\xE1\xDF\x82\xCA\xEE\xE0\xE3\x89\xD0\xEB\xE2\xDA\x6D\xD5\xE1\xDE\xDB\x64\xE5\x00\xE3\xE3\x94\xD7\xE6\xE4\xD9\x9D\xE0\xEF\xCB\xE7\x0A\x66\x0B\xE6\xE4\x9C\xE3\xEE\xE7\xEA\xA2\xFA\xCC\xE8\xDF\xA1\xF0\xEA\xE9\xEB\x70\xF4\xE2\xDD\x42\x27\x27\xE1\xED\xDA\xB3\xF2\xEE\xEA\xED\x98\xFE\xE5\xEE\xF0\xB7\xCD\xE8\xEB\xF1\xBB\xC6\xF9\xF1\xE4\xCB\xD3\xED\xEE\xD8\x28\x3A\xEF\xF2\x41\x29\x12\xFF\xEC\xF1\xC1\xFC\xE7\xF6\xF6\xC3\xDC\xF5\xF0\xF3\xD3\xE0\xFB\xF6\xF2\xE1\xCE\xF3\xFA\xF8\xDD\xE4\xF7\xFA\xF9\xE9\xE8\xFF\xF4\xFB\xEF\xE9\xEC\x6E\x45\x7A\xCD\xF2\xFD\xFB\xF0\xD9\xFA\xF8\xFE\xF7\xF1\xF8\xF1\xF9\x01\x2B\x07\xE9\x2C\x06\x7A\xFE\x7F\x7B\x7D\xFD\x7A\x7E\xFB\x0A\x89\x7E\xD2\x62\x6D\x05\xA7\x6E\x05\x01\xFE\x76\x7F\x6B\x6F\x03\x82\x0C\x89\x82\x03\xFB\x74\x82\x00\x87\x86\x80\x15\x81\x86\x07\xA2\x88\x81\x0F\x9D\x85\x84\x06\x70\x04\x06\x9B\x8B\x80\x16\x8B\x70\x23\xF5\x63\x86\x0C\xA8\x83\x86\x10\xB5\x87\x84\x36\x94\x86\x0E\xB9\x8C\x86\x1C\xBE\x81", + "\x83\x26\x80\x88\x09\xBD\x82\x89\x1B\x85\x8B\x87\x3F\x98\x5E\x0C\x2B\x8F\x74\xEF\x47\x8C\x88\x2E\x9A\x80\xC0\x33\x00\x36\x1A\x30\x35\x06\xB0\x36\x04\x6C\x1A\x2A\x6E\x1C\x30\x31\x07\x4C\x8F\x26\x0E\x61\x88\x7B\x28\x81\x8A\x37\x3B\x04\x8E\x13\xE6\x83\x89\x24\x8D\x8C\x83\x4F\x8E\x8C\xF0\x6C\x86\x88\x3A\x88\x89\x8E\x78\x96\x8C\x14\xEF\x83\x20\x1E\x2A\x88\x8E\x7A\x92\x8D\x19\xFC\x8D\x80\x42\x92\x8B\x8E\xCC\x3C\x21\x0C\xF7\x81\x91\xD6\x3E\x07\x8F\x2D\x86\x93\x19\x92\x9D\x8D\x3C\x94\x95\x8E\x97\x8C\x91\x26\xFB\x88\x91\x4E\x83\x96\x93\x6B\x9B\x92\x20\xA1\x90\x94\x40\xA2\x94\x5E\x3F\x10\x91\x21\xA5\x91\x92\x31\x40\x0A\x95\x87\x9F\x92\x2C\xA4\x93\x96\x83\x01\x08\x96\x93\x8C\x97\xE2\x42\x08\x97\x4A\x8D\x97\x97\xA7\x86\x8F\x10\x3D\x98\x92\xB2\x44\x0C\x98\x9A\x9A\x95\x2C\xB4\x9C\x98\x53\x8A\x99\x97\xB5\x8D\x95\x34\xAB\x93\x9B\x65\x86\x7E\x23\x8B\x9C\x91\x35\xD0\x9D\x99\xC8\x46\x08\x99\xDA\x9D\x98\x35\xE2\x96\x9A\x69\xA4\x9C\x9B\xCE\x9B\x9A\x2F\xC1\x9C\x9D\x67\xAB\x9E\x9D\xC5\x9B\x9B\x11\x30\x38\x08\xD8\x09\x08\x36\x4A\x10", + "\x34\x48\x7A\x6C\x08\xD8\x0D\x08\x97\x4E\x00\x9F\x28\xE9\x9A\x43\x27\x02\xA6\x92\xF0\x89\x9A\x3A\xF1\x97\x9D\x77\x8B\xA2\xA1\x0D\xAC\xA0\x41\x93\xA6\x9C\x8A\xBE\x48\x0A\x07\xA0\x99\x42\xE1\x96\xA3\x72\xA3\x9D\xA3\xC7\x71\x09\x46\xED\x9F\xA0\xDF\x22\x21\x9B\x03\xB5\xA2\x4A\x9F\xAB\xA4\x8F\xAE\xA0\x9D\x2D\xB0\xA4\x4B\xB3\xAF\xA4\x87\x91\xA0\xA2\x20\xB6\xA4\x99\x53\x00\x36\x2A\x30\x35\x0A\xB0\x36\x08\x6C\x57\x00\x36\x92\x3A\x69\x0B\xB8\x9A\x0B\x48\x9B\xA9\xA4\x81\x1B\x0B\xA9\x25\xAD\xA9\x4D\x92\xA1\xA6\x9D\x95\xAC\xAA\x34\xB2\xA7\x54\xB8\xA7\xAA\xAE\x99\xAE\x24\x28\xA8\xA1\x54\xE2\xA7\xA6\x8E\x9D\xAE\xAC\x8B\x7D\x08\x54\xE5\xA6\x5A\x2F\x2B\xA9\xA7\x58\xBB\xA8\x5A\xF2\xA2\xAA\xAD\xB6\xAE\xAA\x59\xB8\xAC\x5D\xE4\xA0\xAE\xAF\xBB\xAA\xA3\x63\xA0\xB2\x86\x5F\x0F\xAD\xB3\xB5\xAA\xAF\xC7\x60\x0C\x6C\x61\x05\xB1\xBC\xB1\xAF\x78\x62\x0D\xB3\x5F\xA4\xAC\xAC\x7A\x63\x0A\xB2\x77\xAF\xB2\xC1\x64\x08\xB2\xC4\x9E\xB2\xB3\xA0\xBE\xAD\x66\x94\x65\x0D\xCE\xA1\xB6\x37\x66\x06\xB6\x68\x9F\xBB\xB5\xD3\x87\xB6\xB5\x7C\xA6\xB1\x6C\x8E", + "\xBD\xB4\x8A\x67\x0A\xB5\x73\xA3\xB5\x6E\xD5\x38\x0C\xDC\xAF\xB5\xB6\xBB\xB0\xB6\x60\xFD\xA1\xB8\xE0\xBF\xB5\xB8\xC8\xA7\xBA\x72\xB3\xBF\x71\x34\x30\x32\x0D\xB0\x2B\x0C\x6C\x6C\x00\x37\x36\x30\x36\x0D\xB0\x2F\x0C\x2E\xF0\x0E\xB6\xE6\xB6\xA9\x0E\xDD\xA3\xBA\x6C\xE2\xB4\xB7\xE4\x9E\xBC\xB5\xE6\xA4\xBF\x64\xCC\xA7\xBC\xE1\x80\x62\x0E\xE1\xB4\xB0\x71\xCB\xBA\xBC\xDD\xB4\xB8\x60\x73\x11\xBC\x7B\xF5\xB4\x0E\xFD\x81\xB2\xBE\xE3\xA0\xC1\x79\xF7\xBB\xBE\x01\xEB\xBF\xBF\x05\xC9\xC0\x82\x8B\xC5\xB3\xFA\x95\x85\x0E\xFE\xAD\xC2\x81\xF6\xB4\x5E\x3B\x11\xC3\xBE\xED\xB4\x63\x1D\x17\xC1\xC0\x05\xD2\xC6\xC3\x18\xCE\xC2\x76\x78\x0C\xC3\x01\xED\x31\x0F\x25\xC7\xC3\x87\x8C\xC1\xC5\x09\xE8\xBC\xC0\x2C\xDD\xC1\x8C\xD9\xAA\x0F\x14\xD4\xC2\xC4\xBC\x3B\x0C\x6C\x7C\x00\x37\x3E\x38\x96\x0F\x36\xCF\xC5\x86\xE9\xBE\xC4\xF7\xA0\xC2\xC6\x2B\xC9\xC9\x8B\xC7\xC2\x21\x3F\x01\xCE\xC8\x33\xCA\xC7\x92\xD1\xC6\xAE\x40\x0F\xCE\xB8\x43\xD0\xC6\x92\xC8\xC0\xA5\x40\x17\xCC\xC8\x4C\xD2\xC8\x97\xE3\xC9\xAA\x41\x1F\xCA\xCB\x53\xDB\xCA\x89\xB8\xC0\xCC\xBE", + "\x43\x10\x36\x84\x10\x35\x21\x38\x96\x11\x33\xD9\xCE\xBB\x87\x16\xCC\x9B\xE8\xC4\xCC\x31\xEB\xCD\xC8\x58\xDB\xCC\x10\x88\x10\x37\x44\x30\x32\x11\xB8\x8B\x12\x9E\x80\xD9\xB6\x46\x0B\xD4\x6C\x8D\x0F\xD0\x95\xC2\xC2\xD1\x4A\xCC\xD4\xCF\x7E\x4E\x10\x6C\x0F\x10\x36\x48\x38\x91\x12\x92\xCA\xCF\x4B\x92\x11\xD5\x34\xE6\xD5\xCF\x37\xD7\xD3\x9D\x96\xDF\x99\x49\x38\x94\x12\xB0\x35\x10\x6C\x16\x18\x97\x4B\x25\xD0\xD5\x15\x98\x13\xAD\x8B\x79\x12\x5C\x9A\x10\x36\x9B\x10\x34\x27\x38\x9D\x13\x5D\xFE\xCF\xA5\x9E\x06\xDB\xF1\x22\x02\x45\x80\x0C\x29\x21\xDE\x24\x3B\xB3\x86\x21\xDA\xE3\x13\xDB\x20\xD5\xC2\x3B\xB5\x82\x29\xDB\xE5\x1B\xD9\x20\xDD\xDB\x3B\xB7\x80\x01\xDC\xA0\x23\xDD\xDC\x37\x23\xDD\x78\x2B\x50\x28\xD9\x09\x26\x43\x7D\x2D\xD8\x51\x5B\x3E\xDC\x83\x00\x44\x38\x55\x3D\x2C\x50\x72\xD4\x29\x76\xCA\x27\xDE\xC6\x39\xDC\x71\x40\x2F\x2A\x7D\xE9\xDB\xDE\xC4\x2F\x36\xC1\xB4\x25\xDE\x84\xDB\x3C\xDF\x02\xE6\x39\xC3\x8B\x23\x3B\x88\xC2\x3B\xDF\x0A\x36\xE3\x72\x13\xE1\x20\x80\xC2\x3A\xE3\xDB\x24\xE3\x74\x66\xDE\xE0\xE1\x0A\xE3\xE0", + "\x37\x3C\xE1\xBF\xB7\x2C\xDF\xA7\x3D\x2A\xE5\x1E\xEB\x38\xC8\xC0\x28\xE3\x84\x2E\xE4\x38\x30\xF5\xE3\xC8\xB7\x25\xE0\x94\xF4\x23\xDC\xC9\x27\xE6\x71\x7E\xD5\xE5\x87\xCA\x23\xDC\x44\xF6\xDE\xCE\x8B\xE1\x26\x7E\xC8\xE9\xE5\xFF\xCB\xEA\xCF\xB1\x2D\xE7\xA1\xC7\xE5\xE8\x40\x22\xEB\xC5\xD0\xE8\xEA\x96\xCC\x59\xE7\x7D\x33\xE4\xCD\xB4\x2C\xDE\x7E\xC9\xEB\x20\x31\xFB\x3A\xD8\xE3\xED\x25\xAA\xDB\xEF\xE7\x45\xFB\x3A\xD6\xCB\x37\xEC\x84\xF5\xE6\x20\x58\x2F\xE5\xD4\xE1\xEB\xE6\xB2\xCA\x21\xEF\x38\xFB\xEC\xBE\xFD\xE4\xEA\xC2\xED\x20\xE8\xD3\x33\xED\xC8\xDC\xE5\xE5\xBB\xC3\x22\x2A\x7A\xE9\x21\xDA\xC0\x2B\xEC\xB6\xEB\x24\xDF\x90\xE1\xF2\xE4\xD2\xE6\xEA\x9A\x2E\xEC\xEE\x57\xED\xF3\x4D\x0A\xF6\xF3\x96\x2A\xE1\x39\x95\xF6\xF1\xEA\xEC\xEF\xF3\xC5\xF0\xED\xEB\x34\x24\xF5\xE9\xAB\x27\xF4\xCE\xEF\xE9\x26\xAB\xE3\xED\xEB\xB3\xFB\x24\xC4\xFD\x2A\xF6\xB3\xF5\xF4\xBB\x8C\xF3\x20\xB3\xE1\xF5\xF8\x29\x75\xEE\xB3\xC9\xF4\xF8\x81\x06\xFC\x26\xB9\xF4\xE7\xB8\x99\xFE\x5C\xE5\xC0\x00\xF0\x01\xE6\xF0\x4B\x63\xD7\xE7\xEA\xCD\xF9\x20\xD4\xFA\xDA", + "\x42\x61\xFC\x5E\xEB\xD8\xFA\xFC\x51\x2C\xF8\xC3\xFF\xE6\xF6\xD0\xEF\xF6\x20\xF0\xCC\x5E\xF5\xC1\x4D\x2F\x73\xD3\x3E\xFE\xF5\xEA\x20\xBA\xEF\xF8\xDB\xFB\xFA\xFE\xFF\xD0\x60\x80\xD4\x62\x80\x03\x1B\x6E\xF2\x7F\x7D\x00\x01\x7F\xD9\x7C\x74\x87\x72\x78\xDE\x7B\x7E\xE9\x79\x7F\xEF\x64\x80\x1D\x2D\x7E\xAE\x71\x13\xE3\x60\x7C\x18\x8F\x7F\x12\x83\x80\x1D\x8D\x7F\x1F\x8C\x6D\x14\x80\x6E\x23\x84\x6E\x25\x8B\x7F\x1B\x89\x10\x06\x8F\x80\x31\x1A\x72\x0A\x8F\x71\xDA\x7D\x7B\x0A\x1A\x72\x24\x71\x80\x21\x84\x82\x37\x86\x82\x39\x88\x82\x0D\x86\x83\xD2\x6C\x81\x3F\x8E\x83\xD6\x60\x1E\xEA\x7D\x82\x0A\x1F\x82\x32\x71\x83\xFF\x03\x6E\xBB\x7A\x25\xD6\x74\x7E\xE2\x6A\x10\x1A\x8D\x83\x06\x14\x83\xC7\x72\x10\x56\x80\x7D\x4A\x83\x6E\xE7\x7E\x6D\x40\x83\x84\x42\x88\x7E\x1E\x81\x84\x63\x80\x86\x65\x82\x86\x20\x84\x86\x69\x86\x86\x05\x85\x84\xA6\x77\x84\x16\x8C\x7B\x4B\x89\x71\x6E\x8C\x12\x2A\x70\x85\x35\x88\x77\x71\x8C\x7B\xDD\x77\x7B\x54\x83\x10\x7D\x8B\x1C\x81\x87\x81\x7F\x84\x71\x7D\x13\x88\x72\x8C\x84\xD3\x18\x88\xBC\x73\x6E\xD1\x78", + "\x87\xBC\x71\x7D\x40\x10\x89\xB3\x72\x89\x37\x14\x89\xA5\x76\x89\x34\x18\x89\xAA\x7A\x84\x8C\x83\x7B\x9F\x85\x7A\xDC\x7B\x88\x9E\x8B\x85\x0E\x82\x1C\xA1\x86\x79\xA9\x8C\x76\x8A\x87\x88\xA5\x8C\x80\xDB\x74\x87\xAE\x80\x8B\x32\x81\x56\x2B\x1B\x8A\x63\x73\x8A\xB3\x83\x75\x85\x8D\x71\xA4\x84\x8B\x73\x89\x10\x4D\x84\x13\xB8\x82\x7D\xB2\x8A\x86\xCE\x7B\x87\xB3\x73\x6E\xFE\x1B\x8B\x9D\x71\x13\xC5\x89\x87\x80\x85\x82\xCD\x84\x1C\xD1\x87\x13\xD7\x8C\x7F\x86\x88\x8C\x01\x15\x8D\xC6\x19\x8D\xD0\x86\x8A\xC2\x84\x8D\xBF\x8C\x8B\x2C\x10\x8E\xBD\x80\x00\xD1\x7C\x8C\xE5\x8F\x8C\xE9\x8F\x7C\xB8\x7F\x8A\xE6\x87\x8B\xE2\x86\x10\xC5\x88\x8E\xE7\x85\x8F\x68\x7D\x8E\x7E\x89\x8F\xC0\x8D\x8A\xD6\x82\x8F\xEE\x81\x8B\x09\x11\x7D\xF8\x85\x8B\x21\x2A\x8C\xA5\x77\x90\xFF\x0C\x90\xBA\x81\x90\xC0\x8E\x90\xA7\x82\x88\x02\x9D\x8F\x08\x93\x10\xC3\x81\x8E\x11\x9A\x8F\x02\x16\x90\x1C\x91\x10\xF0\x8F\x86\x05\x93\x1D\x2A\x71\x7D\x2A\x7D\x25\x91\x76\x10\x3E\x2A\x79\x2A\x94\x92\x44\x89\x92\x03\x1E\x8D\xC2\x1A\x72\x59\x86\x84\x61\x8B\x71\x5F\x83\x93", + "\x52\x8E\x92\xE3\x8D\x17\x9C\x8C\x76\x2A\x75\x8C\x3F\x93\x76\x41\x9C\x93\x06\x10\x22\x12\x7A\x10\x48\x9A\x93\x09\x1B\x94\xCB\x1E\x5C\x45\x7E\x74\x4E\x13\x95\x36\x74\x95\xF6\x86\x95\xD3\x85\x95\x11\x84\x15\xEC\x79\x10\x5D\x87\x7D\x5D\x9A\x87\x5E\x91\x96\x57\x1E\x15\x66\x9D\x93\x06\x1D\x7A\x6A\x97\x96\x69\x9B\x93\x09\x1A\x72\xE1\x6B\x82\x02\x12\x97\x01\x14\x97\x00\x06\x97\x78\x9F\x92\x06\x16\x97\x32\x9E\x8B\x13\x8D\x94\x0D\x1A\x10\xF4\x7A\x74\x09\x13\x98\x03\x18\x84\x00\x06\x98\x07\x12\x98\x81\x99\x10\x28\x96\x10\x5F\x2B\x79\x09\x11\x99\xF0\x7A\x10\x94\x93\x10\x4E\x90\x00\x97\x92\x10\x2B\x93\x10\x77\x29\x10\x79\x25\x98\x13\x90\x00\xA1\x90\x24\x70\x80\x9A\x8C\x90\x98\xA8\x92\x9A\x09\x1D\x99\x02\x15\x9A\x03\x1F\x98\x03\x1F\x28\xAC\x94\x98\x06\x14\x9B\xA6\x9F\x97\xB7\x99\x9A\x47\x9A\x10\xB8\x93\x10\x8A\x91\x10\xAE\x91\x10\xBF\x92\x10\xB2\x92\x10\x91\x25\x9B\xFB\x89\x10\xC9\x99\x9B\x95\x9C\x9C\xBC\x98\x99\x0A\x1D\x9C\xC0\x9D\x98\x06\x14\x9D\xC6\x9F\x10\x90\x21\x77\x21\x9D\x1A\x83\x87\x35\x71\x7A\x94\xF2\x6D\x72\x0A", + "\x10\x9E\xE1\x9A\x92\xE3\x91\x77\xD1\x37\x9E\x40\x29\x9E\x23\x99\x10\x12\x4C\x9E\xB1\x9E\x9E\x5C\x90\x9F\xF2\x93\x10\x13\x04\x9F\x0E\x78\x45\xF7\x91\x10\x14\x0A\x9F\x08\x79\x46\xFD\x94\x9A\x00\xA1\x10\xAD\x77\x4B\x03\xA6\x01\x05\xAE\x1A\x0A\x1C\x4B\x03\xA7\x01\x0B\xAA\x78\x0E\xAD\x9F\x18\x0B\xA0\x2F\x17\x4F\x03\xA9\x01\x0B\xA1\x6E\x06\x53\xA0\x1A\x0B\xA0\x50\x8E\x53\x45\x75\x8C\x2F\x1F\x95\x44\x53\xA2\x7C\x2A\x72\x42\x58\xA2\x1A\x26\x97\x40\x5C\xA2\x64\x2D\x97\x00\x0F\x54\x30\xA3\x10\x1B\x0B\xA0\xE3\x6A\x54\x03\xAC\x01\x0B\xA2\xA3\x34\xA5\x72\x83\x8D\x01\x38\xAA\x10\x3A\xAD\x9F\x1E\x0B\xA0\x69\x7E\x56\x03\xAF\x01\x48\xAA\x10\x84\x53\xA0\x20\x0D\xA4\x09\x1F\xA4\xFD\x91\x02\x0B\xAF\x09\x71\x7F\x74\xBC\x11\x9E\xDD\x98\x2F\x25\xAC\x27\x45\x18\x4B\x2F\x11\x7D\xE1\x93\x6E\x5D\xA0\x30\x2F\x13\x94\xCC\x1F\x12\x83\x87\xA6\x62\x2F\x12\x53\x8D\x1A\x69\xA2\xA6\x58\x9E\x27\x63\xA4\xA7\x68\x90\x25\x5F\xA6\x8B\x68\xA3\x83\x60\xAC\x96\xC8\x79\x10\x8A\x7A\xA5\xBE\x16\xA6\x7F\xA7\x93\x00\x04\xA2\x7C\x2C\x8E\x1A\x2F\x12\x69\x7F", + "\x95\x9B\x90\x92\x7C\x2D\xA6\x87\xA6\x10\x9F\x97\x95\x62\x33\x88\x32\xA5\x1D\x2F\x18\x9D\x01\x1F\x95\x0C\x3C\xA7\x73\xA2\xAA\x71\x77\x32\x5A\x96\x3C\x50\x8B\xA9\xDA\x1F\x12\x59\x33\x96\xB8\x37\x3A\x20\x7E\xA6\xEA\x95\xA7\x8F\x30\x72\xAA\xAB\xA5\x0A\x12\x40\xAE\xA6\x10\x30\x49\x90\x1A\x2F\x95\xB2\xA5\x74\x4B\x47\xAA\x91\x3F\x95\xB7\xAE\x1B\x2F\x1C\x9F\x62\x96\x10\x02\xAE\xAB\x64\x2D\x7A\xC1\xA5\x72\x7E\x44\xAC\x8B\x3D\x7A\xC7\xA9\x1A\x2F\x19\x4A\xBB\xA3\x10\xD8\x4E\xAC\x50\x2A\x78\xD1\xAE\x70\xDF\x44\xAD\x8F\x3A\x78\xD7\xA2\xA7\x0A\x18\xA1\xCB\xA3\x10\x1D\xAE\xAD\x7E\x2A\x72\xE1\xA8\x70\x18\x54\xAA\x1A\x2A\x72\xE7\xAA\x1B\x2F\x12\x52\x5B\x93\x10\x2F\xAE\xAE\x57\x21\x6E\xF1\xA3\x6F\x2B\xAE\xAF\xC7\x31\x6E\xF7\xAB\xA6\x0A\x17\xA2\x06\x10\x85\x3F\xA1\xA8\x64\x26\x97\x3C\x88\xAE\xE7\x42\xA3\x76\x9C\xA9\xDB\x49\x76\x99\x96\xB1\x1A\x20\x56\x4B\x1C\x27\x99\x98\x98\x1A\xB0\x52\xC3\x90\x00\xC7\x97\x25\x2F\x1A\xA4\x04\xB6\x30\x25\xBA\x99\x95\xA0\x25\x54\xA3\x10\x84\xA9\x1A\x91\xA0\x00\xC5\x96\xB2\xDB\x43\xB3\x97\xAA\xA7", + "\xDB\x49\xB3\x8B\x9D\xA8\x7C\x2C\x58\x09\x1E\x7B\x04\xB0\x9B\x02\x15\xB3\xD7\x2F\x4C\x46\xB1\x9C\x47\xBA\x10\x97\x54\xAF\x64\x2E\xA9\xA4\x9D\xB2\x59\x55\x2A\x06\x1F\x2D\x64\x2F\x12\x9C\x5A\x37\xA5\x51\xB4\x7C\x2B\x2C\x09\x18\x2A\x3E\xB9\x10\xB7\x5E\xB4\x50\x26\xB5\x03\x1E\xB5\x57\xBB\x4D\xF1\x26\x10\xA6\xA9\xB6\x09\x1D\x5B\x64\xBE\x27\x6D\xB3\x10\x66\x31\xB6\x64\x20\x95\x1D\xBA\x21\x44\x39\x10\x66\xB6\xA7\x0A\x12\x5D\x7A\x34\x5D\x5C\xBA\x37\xFC\x6B\xB7\x06\x1D\xAA\x6E\xB0\x52\xE6\x96\xA3\x52\xB1\x10\xD8\x5A\x37\xDA\x53\xB8\x79\xB4\xB0\x8B\xB2\x10\x88\xBA\xB3\xE7\x47\xB9\x02\x11\xAA\x89\xB3\x10\xE0\x51\xB7\x57\x25\xB7\x43\x3D\xB8\x76\x59\x37\x06\x1A\x39\x76\xB3\x10\xF0\x50\xBA\xD7\x28\xBA\xD4\x34\xBA\xD5\x19\x5F\x92\xB0\x25\xA6\x33\xBB\x7E\xB9\x10\x10\x6C\xBA\x94\xA9\x10\xB5\xBB\xAE\xB7\xB6\x10\x16\x6C\xBA\x50\x8C\x6F\xBD\xB3\x10\x64\xA1\x77\x1B\x6C\xBA\xB1\xA5\x3A\xE3\x74\xBA\x24\x6C\xBA\xC0\xAC\xBC\x82\xA4\xBA\x28\x6C\xBA\xD0\xA2\xBD\x98\xAD\xB9\x02\x15\x63\xAC\xB0\xAE\xD8\xB8\x91\xA4\xBA\x63\xAC\xB0\xAF\xDF", + "\xB8\x85\xA4\xBC\x63\x7A\x3E\x63\xB6\xB8\x83\x04\xB9\x3B\x7E\x34\xBA\x4E\x6C\xBA\xD5\x1B\x9E\x06\x1E\xBE\xDA\xBF\x52\xD5\x3C\xBB\xB0\xBE\x41\xF4\x36\x10\x04\x49\xBA\x02\x16\x65\xF2\xBA\x1D\xFF\xB6\x10\x2A\x40\xC0\x57\x2E\x65\xEB\xB7\x2D\x10\x49\x10\xAE\xB8\xB9\x06\x1F\x66\xAC\xB6\x97\xFC\x6D\xC0\x06\x17\x41\x08\xC6\x57\xF1\x97\xBA\xA4\xB1\x67\xAC\xB2\xA3\xFC\x6B\xC1\x03\x18\xC1\xF7\xB6\x57\x24\xC3\x10\xBA\xA5\xC2\x73\x63\xC0\xBC\x17\xC0\x06\x16\xC1\x10\xC1\x53\xBD\xA3\x10\x5A\x49\xC1\x75\x6C\xC2\xBE\x14\x45\x0B\xC1\xB2\x03\x19\x67\xAC\xB9\x76\xFC\x6A\xC3\xBE\xB6\xB3\x09\x14\x68\xAC\xB8\x98\x41\xC7\x8C\x31\xC2\x10\x86\x6C\xBA\x99\x99\xC4\xFB\xAF\xBB\x03\x18\x68\xAC\xB3\xB2\x50\xC6\x10\x71\xA8\xAF\x0A\x1A\x68\xAC\xBA\xB4\x57\xC9\x95\x25\xCE\x68\xAC\xBB\xB2\x5F\xC2\x10\x19\x98\xAD\x0A\x11\x69\xAC\xB3\xB3\x65\xC1\x10\x35\x98\xC6\x09\x1A\x69\x7A\x3C\x69\x0B\xCC\xB3\x92\xA9\x10\x56\x49\x10\xC3\xA5\xC2\xA0\x68\xC3\xA9\x1A\xAC\x03\x19\xC7\x25\xC5\x41\x35\xC6\x10\x42\xCB\xC4\x2F\x5C\x45\x06\x13\xAD\x25\xC4\x6A\x7E\xCD", + "\x1A\x60\x4B\xC3\xAB\xAA\x10\xAE\x6C\xBA\x44\xB7\xC7\x06\x11\xC9\x43\xCB\xB4\x09\x10\x6B\xAC\xB6\xB4\xFC\x6A\xC9\xC6\xB4\xBA\xB2\x6C\xBA\x50\xB1\xCA\xCD\xB9\xC1\xB4\x6C\xBA\x54\xBE\xB0\x03\x12\xCA\x02\x19\xC5\x08\xB9\x10\xB6\x6C\xBA\x60\xB4\xB0\xB0\xC1\x10\x8A\xA5\x74\xBA\x6C\xBA\x68\xBE\xCA\x02\x19\xCB\x00\x07\xC6\x12\xB6\x10\xBD\x6C\xBA\x7D\xB8\xC9\xAF\xCE\xA7\x19\xCF\x6B\x7A\x31\x6C\x0B\xCB\xB6\xC0\xC1\x10\x63\x49\x10\x5E\x49\xC1\xC5\x6F\xC8\x68\x4A\x10\xD5\xC3\xC8\x1E\x4C\xC8\xCB\xC9\xC1\x15\x4A\x48\x06\x1A\xAD\x25\xC9\x6C\xDA\xCC\x1C\xE6\xC3\x10\xC7\x42\xCE\xDA\x18\xA5\x92\xCC\x1B\xAF\x49\x10\x85\xC8\xC8\x00\x01\x0A\xA7\x3C\xB9\xD3\xC0\x00\xF3\xCB\xC8\xA4\xB2\x0A\xA7\x33\xB7\xC9\x89\x10\xFD\xC3\x10\xC3\x4E\xCE\x25\x48\xA0\xFE\xC9\xC1\xA3\x07\x3A\x86\xBB\xCF\x0A\xD6\xD0\xFB\xB5\x42\x13\xA2\xD1\x08\xD6\x40\x07\xD6\x10\x8F\x49\xC1\xA4\x08\x4B\xED\xC6\x10\x05\xD2\xC5\x59\x5D\xAD\x03\x19\x4F\x19\xC5\x0A\xB8\x43\x4F\xF1\xC8\xAC\x0A\x16\x0A\xA7\x35\xB9\xCA\xC2\x10\x2A\xDB\xC9\x3C\xC2\x10\xA7\x07\x3A\x9A\xB1\xD3", + "\x01\x13\xD3\xA3\xC9\xC1\xA8\x07\x3A\xA2\xBB\xCF\x3C\xD2\x10\x6A\xA1\x9E\xA9\x07\x3A\xA6\xB2\xD4\x6E\x95\xC2\xAA\x07\x3A\x7F\x3A\x37\x43\xDA\xCB\xA4\xBB\x0A\xA7\x3F\xC0\x03\xD6\x10\x51\xD3\xCC\xA4\xBC\x0A\xA7\x35\xBC\x57\xD3\x10\x59\xDF\xC6\xC5\xC3\x10\xAD\x00\x1B\xAE\x07\x74\x0A\x16\xBF\xFB\xC5\x4F\x09\x13\xAE\x25\xC0\x0B\xB8\x4A\xAE\x03\x1C\xD6\xDE\xC5\x42\x26\xD8\xD5\x13\xD6\x40\xFB\x46\x10\xFF\x49\xC1\xB1\x08\x4B\x7D\xD6\x10\xFA\xA5\xD7\xBE\x12\x0B\x68\xDA\x21\x01\x59\x10\x77\xD6\xCF\xB4\x07\x3A\xF4\xBB\xCF\x89\xD6\x10\xF3\xA4\xD8\xFE\x3D\xAE\x03\x13\xD9\xF6\xC5\x41\x98\xD2\x10\xFD\x49\xC1\xB5\x08\x4B\x83\xD3\x10\x91\xD9\xD9\x1E\x47\x52\x6C\xB4\xBA\xB6\x07\xD8\x64\x29\xBF\x04\xB6\xDA\x03\x15\xC0\xF6\xC8\x0B\xAA\xD0\x25\xFD\xBB\xCF\xAE\xD2\x10\xEB\xC2\xD2\x01\x1A\x0B\xB3\xDE\x27\x29\xC6\xDB\x0A\x11\xD8\xF6\xCC\x0B\xBD\xD7\x25\xB0\xDF\xD5\x02\x12\xA2\x06\x1C\x53\x19\xCE\x0B\xC5\xD7\x3C\xFD\xA3\x10\xCC\xD5\xC2\xC0\x0F\xDC\x06\x33\xB0\xD2\xD4\xBA\xC2\x06\xDD\x03\x3A\xB0\xD9\xD9\xC1\xC4\x0C\xDD\x14\x36\x54\xA7", + "\xD9\xC1\xC6\x04\xAB\x0C\xCF\xDC\xE4\xDF\xDA\xA4\xB9\x0C\xE8\xD5\x1D\x27\xC2\x10\xE3\x6B\xDE\xB8\xD4\xBA\xCC\x0F\xDE\xDA\x13\xC3\xF2\xD3\x12\xC1\xD4\xBA\xCF\x08\xDF\xBC\x17\xC8\xFB\xD9\x10\xF4\xD1\x10\x2B\xB5\xD3\x01\x12\x0D\xE2\xDE\x1B\x80\xC8\xDC\x01\x15\xA4\x03\x12\xD0\x44\xC6\x10\xD4\x0B\xE0\xA9\x15\xCF\x03\xE6\x10\x10\xE2\x10\xC7\xD3\xE1\x03\x16\x0D\x16\xED\x1A\xD7\xC3\xB9\x03\x1B\xE1\x01\x19\xDB\x1E\xE2\x10\xD8\x01\xE2\xBA\x1D\xCD\x30\xB4\xA4\xFD\xD9\xC1\xDA\x0C\xE2\xCC\x10\xCE\x19\xE5\xE2\x0A\x17\xE0\x93\xC9\x10\xDC\x07\x3A\x1B\xD4\xB0\x0D\xB2\x10\x48\x59\xC1\xDD\x08\x4B\x1C\xB1\xE1\xA4\xBE\x0D\xA9\xC4\x26\x28\xE9\xA8\x25\x1A\x10\x1D\xEC\xC9\x06\x12\x0E\x4B\xE0\x25\x15\xD2\x10\x83\x87\xE4\xF5\xD9\xC1\xE6\x05\xE5\x7E\x24\xD2\x58\xEF\xE4\x09\x12\xDC\xBA\xD0\x00\xEA\x0E\xE5\x57\x24\xD7\x60\xC3\x10\x5A\xE6\xE0\xA4\xBE\x0E\x00\xEE\x1B\x7B\xDF\xE2\x09\x18\xB2\x03\x1A\x56\x19\xC1\x0F\xB8\x46\xE7\x02\x12\xE1\x52\xE3\x10\xF2\x01\xE7\xA9\x14\xE6\x52\xD5\xE7\x50\xE4\xBA\xF5\x02\xE8\xAD\x1B\xD9\x85\xE6\x10\x7C\xE7", + "\xE2\xA4\xB8\x0F\x8A\xEA\x1B\xD3\xDB\xE6\x02\x1F\xE8\x00\x04\xE8\x7F\xE2\x10\xFB\x03\xE9\xCC\x18\xDD\x61\xE6\xE8\x8E\x94\xBA\xFE\x04\xE3\x2F\x13\xE4\x24\xE2\x10\x2F\xB2\x10\x78\xE5\xC2\x00\x0B\xA0\x06\x3B\xEA\x01\x1E\xE7\x08\xEF\xEA\xF2\x6B\xCB\x06\x11\xE4\x8D\xE3\x10\xB2\xE0\x00\x51\xE5\xEB\x04\x07\xEB\x7C\x28\xE9\x83\x8D\xEB\x4D\xE5\xEB\x07\x02\xEC\x1A\x20\xB4\xD9\xBC\xEB\x31\xE5\xC2\x0A\x0A\xEC\x64\x29\xB5\xCD\xEA\xEA\x39\xE4\xBA\x0D\x02\x6F\x31\xBD\x1A\x63\xB9\xEA\x01\x1A\x58\xB0\x78\xAC\x34\x73\xA0\x1D\x91\x9E\x83\x84\x14\x42\xB4\xB0\x44\x1F\x95\x44\x10\x85\x44\x1D\x7A\x44\x1A\x78\xF1\xE1\x9E\xF2\xEE\xA6\x67\xAF\x0F\xFC\x68\xEE\x03\x2B\xED\x04\x95\x74\xE9\xE4\xE7\xFE\xE5\xA6\x02\xF1\x77\x24\xA1\x8D\xE7\xEC\xA6\xE1\x95\xD4\x6A\xAF\x0F\xEE\xE3\xAA\x45\x7D\xF0\x68\xE3\x6F\x10\xFF\x9E\x07\x22\x89\x20\x74\x14\x17\xF7\xA7\x71\x79\xF1\x4A\xCE\x70\x5F\x9B\x15\x1F\xF0\x14\xEC\xEB\xA7\x45\x73\xF2\x64\x9E\xF1\xE1\x94\xCC\x2E\x1A\xF2\x2B\x10\xEF\x2F\x1E\xF2\x80\xAE\x70\x30\xF3\xBD\x7F\x12\xCB\xFF\x02\xEF\x70\xA4\xEF", + "\x3A\xF1\x77\x62\xDE\x12\x3D\xF4\x7B\xE1\x92\x7C\x6F\x91\xF4\x44\xFC\xF3\xE1\x91\xB1\x2E\x18\xF4\x2B\x11\x6E\x44\x1C\xF4\x2F\x1E\xF4\x39\x98\x70\x15\xB3\x14\x53\xF7\x13\x76\x94\x14\x57\xFF\x12\x59\xFA\x97\x25\x7B\xF5\x09\x17\xB0\x00\x07\xB0\xFF\x02\xA3\x44\x12\xA3\xE7\xE2\xA3\x40\x70\xC2\x8E\xA3\x20\x93\x70\x14\x69\x74\x14\x6F\xFF\x12\x20\xB3\x14\x73\xF7\x13\x88\x94\x14\x77\xF1\x9E", + }; + vl::glr::DecompressSerializedData(compressed, true, dataSolidRows, dataRows, dataBlock, dataRemain, outputStream); + } + + const wchar_t* ParserRuleName(vl::vint index) + { + static const wchar_t* results[] = { + L"RType", + L"RAttributeParameter", + L"RAttribute", + L"REnumMember", + L"REnum", + L"RStructMember", + L"RStruct", + L"RMessageRequest", + L"RMessageResponse", + L"RMessage", + L"REventRequest", + L"REvent", + L"RDeclDetail", + L"RDecl", + L"Schema", + }; + return results[index]; + } + + const wchar_t* ParserStateLabel(vl::vint index) + { + static const wchar_t* results[] = { + L"[0][RType] BEGIN ", + L"[1][RType] END [ENDING]", + L"[2][RType]< \"bool\" @ >", + L"[3][RType]< \"char\" @ >", + L"[4][RType]< \"double\" @ >", + L"[5][RType]< \"float\" @ >", + L"[6][RType]< \"int\" @ >", + L"[7][RType]< \"key\" @ >", + L"[8][RType]< \"string\" @ >", + L"[9][RType]< NAME @ >", + L"[10][RType]< RType \"[\" \"]\" @ >", + L"[11][RType]< RType \"[\" @ \"]\" >", + L"[12][RType]< RType @ \"[\" \"]\" >", + L"[13][RAttributeParameter] BEGIN ", + L"[14][RAttributeParameter] END [ENDING]", + L"[15][RAttributeParameter]CPP_NAME @", + L"[16][RAttribute] BEGIN ", + L"[17][RAttribute] END [ENDING]", + L"[18][RAttribute]< \"[\" @ ATT_NAME [ \"(\" RAttributeParameter \")\" ] \"]\" >", + L"[19][RAttribute]< \"[\" ATT_NAME @ [ \"(\" RAttributeParameter \")\" ] \"]\" >", + L"[20][RAttribute]< \"[\" ATT_NAME [ \"(\" @ RAttributeParameter \")\" ] \"]\" >", + L"[21][RAttribute]< \"[\" ATT_NAME [ \"(\" RAttributeParameter \")\" @ ] \"]\" >", + L"[22][RAttribute]< \"[\" ATT_NAME [ \"(\" RAttributeParameter \")\" ] \"]\" @ >", + L"[23][RAttribute]< \"[\" ATT_NAME [ \"(\" RAttributeParameter @ \")\" ] \"]\" >", + L"[24][REnumMember] BEGIN ", + L"[25][REnumMember] END [ENDING]", + L"[26][REnumMember]< NAME \",\" @ >", + L"[27][REnumMember]< NAME @ \",\" >", + L"[28][REnum] BEGIN ", + L"[29][REnum] END [ENDING]", + L"[30][REnum]< \"enum\" @ NAME \"{\" { REnumMember } \"}\" >", + L"[31][REnum]< \"enum\" NAME \"{\" @ { REnumMember } \"}\" >", + L"[32][REnum]< \"enum\" NAME \"{\" { REnumMember @ } \"}\" >", + L"[33][REnum]< \"enum\" NAME \"{\" { REnumMember } \"}\" @ >", + L"[34][REnum]< \"enum\" NAME @ \"{\" { REnumMember } \"}\" >", + L"[35][RStructMember] BEGIN ", + L"[36][RStructMember] END [ENDING]", + L"[37][RStructMember]< \"var\" @ NAME \":\" RType \";\" >", + L"[38][RStructMember]< \"var\" NAME \":\" @ RType \";\" >", + L"[39][RStructMember]< \"var\" NAME \":\" RType \";\" @ >", + L"[40][RStructMember]< \"var\" NAME \":\" RType @ \";\" >", + L"[41][RStructMember]< \"var\" NAME @ \":\" RType \";\" >", + L"[42][RStruct] BEGIN ", + L"[43][RStruct] END [ENDING]", + L"[44][RStruct]< \"struct\" @ NAME \"{\" { RStructMember } \"}\" >", + L"[45][RStruct]< \"struct\" NAME \"{\" @ { RStructMember } \"}\" >", + L"[46][RStruct]< \"struct\" NAME \"{\" { RStructMember @ } \"}\" >", + L"[47][RStruct]< \"struct\" NAME \"{\" { RStructMember } \"}\" @ >", + L"[48][RStruct]< \"struct\" NAME @ \"{\" { RStructMember } \"}\" >", + L"[49][RMessageRequest] BEGIN ", + L"[50][RMessageRequest] END [ENDING]", + L"[51][RMessageRequest]< \"request\" \":\" @ RType \";\" >", + L"[52][RMessageRequest]< \"request\" \":\" RType \";\" @ >", + L"[53][RMessageRequest]< \"request\" \":\" RType @ \";\" >", + L"[54][RMessageRequest]< \"request\" @ \":\" RType \";\" >", + L"[55][RMessageResponse] BEGIN ", + L"[56][RMessageResponse] END [ENDING]", + L"[57][RMessageResponse]< \"response\" \":\" @ RType \";\" >", + L"[58][RMessageResponse]< \"response\" \":\" RType \";\" @ >", + L"[59][RMessageResponse]< \"response\" \":\" RType @ \";\" >", + L"[60][RMessageResponse]< \"response\" @ \":\" RType \";\" >", + L"[61][RMessage] BEGIN ", + L"[62][RMessage] END [ENDING]", + L"[63][RMessage]< \"message\" @ NAME \"{\" [ RMessageRequest ] [ RMessageResponse ] \"}\" >", + L"[64][RMessage]< \"message\" NAME \"{\" @ [ RMessageRequest ] [ RMessageResponse ] \"}\" >", + L"[65][RMessage]< \"message\" NAME \"{\" [ RMessageRequest @ ] [ RMessageResponse ] \"}\" >", + L"[66][RMessage]< \"message\" NAME \"{\" [ RMessageRequest ] [ RMessageResponse @ ] \"}\" >", + L"[67][RMessage]< \"message\" NAME \"{\" [ RMessageRequest ] [ RMessageResponse ] \"}\" @ >", + L"[68][RMessage]< \"message\" NAME @ \"{\" [ RMessageRequest ] [ RMessageResponse ] \"}\" >", + L"[69][REventRequest] BEGIN ", + L"[70][REventRequest] END [ENDING]", + L"[71][REventRequest]< \"request\" \":\" @ RType \";\" >", + L"[72][REventRequest]< \"request\" \":\" RType \";\" @ >", + L"[73][REventRequest]< \"request\" \":\" RType @ \";\" >", + L"[74][REventRequest]< \"request\" @ \":\" RType \";\" >", + L"[75][REvent] BEGIN ", + L"[76][REvent] END [ENDING]", + L"[77][REvent]< \"event\" @ NAME \"{\" [ REventRequest ] \"}\" >", + L"[78][REvent]< \"event\" NAME \"{\" @ [ REventRequest ] \"}\" >", + L"[79][REvent]< \"event\" NAME \"{\" [ REventRequest @ ] \"}\" >", + L"[80][REvent]< \"event\" NAME \"{\" [ REventRequest ] \"}\" @ >", + L"[81][REvent]< \"event\" NAME @ \"{\" [ REventRequest ] \"}\" >", + L"[82][RDeclDetail] BEGIN ", + L"[83][RDeclDetail] END [ENDING]", + L"[84][RDeclDetail]<< !REnum @ >>", + L"[85][RDeclDetail]<< !REvent @ >>", + L"[86][RDeclDetail]<< !RMessage @ >>", + L"[87][RDeclDetail]<< !RStruct @ >>", + L"[88][RDecl] BEGIN ", + L"[89][RDecl] END [ENDING]", + L"[90][RDecl]<< { RAttribute @ } !RDeclDetail >>", + L"[91][RDecl]<< { RAttribute } !RDeclDetail @ >>", + L"[92][Schema] BEGIN ", + L"[93][Schema] END [ENDING]", + L"[94][Schema]< RDecl @ { RDecl } >", + L"[95][Schema]< RDecl { RDecl @ } >", + }; + return results[index]; + } + + Parser::Parser() + : vl::glr::ParserBase(&GuiRemoteProtocolTokenDeleter, &GuiRemoteProtocolLexerData, &GuiRemoteProtocolParserData) + { + } + + vl::WString Parser::GetClassName(vl::vint32_t classIndex) const + { + return vl::WString::Unmanaged(GuiRemoteProtocolTypeName((GuiRemoteProtocolClasses)classIndex)); + } + + vl::vint32_t Parser::FindCommonBaseClass(vl::vint32_t class1, vl::vint32_t class2) const + { + return -1; + } + + vl::Ptr Parser::ParseSchema(const vl::WString& input, vl::vint codeIndex) const + { + return ParseWithString(input, this, codeIndex); + } + + vl::Ptr Parser::ParseSchema(vl::collections::List& tokens, vl::vint codeIndex) const + { + return ParseWithTokens(tokens, this, codeIndex); + } +} + + +/*********************************************************************** +.\REMOTEPROTOCOL\GENERATED\GUIREMOTEPROTOCOL_ASSEMBLER.CPP +***********************************************************************/ +/*********************************************************************** +This file is generated by: Vczh Parser Generator +From parser definition:GuiRemoteProtocol +Licensed under https://github.com/vczh-libraries/License +***********************************************************************/ + + +namespace vl::presentation::remoteprotocol +{ + +/*********************************************************************** +GuiRemoteProtocolAstInsReceiver : public vl::glr::AstInsReceiverBase +***********************************************************************/ + + vl::Ptr GuiRemoteProtocolAstInsReceiver::CreateAstNode(vl::vint32_t type) + { + auto cppTypeName = GuiRemoteProtocolCppTypeName((GuiRemoteProtocolClasses)type); + switch((GuiRemoteProtocolClasses)type) + { + case GuiRemoteProtocolClasses::ArrayType: + return vl::Ptr(new vl::presentation::remoteprotocol::GuiRpArrayType); + case GuiRemoteProtocolClasses::Attribute: + return vl::Ptr(new vl::presentation::remoteprotocol::GuiRpAttribute); + case GuiRemoteProtocolClasses::EnumDecl: + return vl::Ptr(new vl::presentation::remoteprotocol::GuiRpEnumDecl); + case GuiRemoteProtocolClasses::EnumMember: + return vl::Ptr(new vl::presentation::remoteprotocol::GuiRpEnumMember); + case GuiRemoteProtocolClasses::EventDecl: + return vl::Ptr(new vl::presentation::remoteprotocol::GuiRpEventDecl); + case GuiRemoteProtocolClasses::EventRequest: + return vl::Ptr(new vl::presentation::remoteprotocol::GuiRpEventRequest); + case GuiRemoteProtocolClasses::MessageDecl: + return vl::Ptr(new vl::presentation::remoteprotocol::GuiRpMessageDecl); + case GuiRemoteProtocolClasses::MessageRequest: + return vl::Ptr(new vl::presentation::remoteprotocol::GuiRpMessageRequest); + case GuiRemoteProtocolClasses::MessageResponse: + return vl::Ptr(new vl::presentation::remoteprotocol::GuiRpMessageResponse); + case GuiRemoteProtocolClasses::PrimitiveType: + return vl::Ptr(new vl::presentation::remoteprotocol::GuiRpPrimitiveType); + case GuiRemoteProtocolClasses::ReferenceType: + return vl::Ptr(new vl::presentation::remoteprotocol::GuiRpReferenceType); + case GuiRemoteProtocolClasses::Schema: + return vl::Ptr(new vl::presentation::remoteprotocol::GuiRpSchema); + case GuiRemoteProtocolClasses::StructDecl: + return vl::Ptr(new vl::presentation::remoteprotocol::GuiRpStructDecl); + case GuiRemoteProtocolClasses::StructMember: + return vl::Ptr(new vl::presentation::remoteprotocol::GuiRpStructMember); + default: + return vl::glr::AssemblyThrowCannotCreateAbstractType(type, cppTypeName); + } + } + + void GuiRemoteProtocolAstInsReceiver::SetField(vl::glr::ParsingAstBase* object, vl::vint32_t field, vl::Ptr value) + { + auto cppFieldName = GuiRemoteProtocolCppFieldName((GuiRemoteProtocolFields)field); + switch((GuiRemoteProtocolFields)field) + { + case GuiRemoteProtocolFields::ArrayType_element: + return vl::glr::AssemblerSetObjectField(&vl::presentation::remoteprotocol::GuiRpArrayType::element, object, field, value, cppFieldName); + case GuiRemoteProtocolFields::Declaration_attributes: + return vl::glr::AssemblerSetObjectField(&vl::presentation::remoteprotocol::GuiRpDeclaration::attributes, object, field, value, cppFieldName); + case GuiRemoteProtocolFields::EnumDecl_members: + return vl::glr::AssemblerSetObjectField(&vl::presentation::remoteprotocol::GuiRpEnumDecl::members, object, field, value, cppFieldName); + case GuiRemoteProtocolFields::EventDecl_request: + return vl::glr::AssemblerSetObjectField(&vl::presentation::remoteprotocol::GuiRpEventDecl::request, object, field, value, cppFieldName); + case GuiRemoteProtocolFields::EventRequest_type: + return vl::glr::AssemblerSetObjectField(&vl::presentation::remoteprotocol::GuiRpEventRequest::type, object, field, value, cppFieldName); + case GuiRemoteProtocolFields::MessageDecl_request: + return vl::glr::AssemblerSetObjectField(&vl::presentation::remoteprotocol::GuiRpMessageDecl::request, object, field, value, cppFieldName); + case GuiRemoteProtocolFields::MessageDecl_response: + return vl::glr::AssemblerSetObjectField(&vl::presentation::remoteprotocol::GuiRpMessageDecl::response, object, field, value, cppFieldName); + case GuiRemoteProtocolFields::MessageRequest_type: + return vl::glr::AssemblerSetObjectField(&vl::presentation::remoteprotocol::GuiRpMessageRequest::type, object, field, value, cppFieldName); + case GuiRemoteProtocolFields::MessageResponse_type: + return vl::glr::AssemblerSetObjectField(&vl::presentation::remoteprotocol::GuiRpMessageResponse::type, object, field, value, cppFieldName); + case GuiRemoteProtocolFields::Schema_declarations: + return vl::glr::AssemblerSetObjectField(&vl::presentation::remoteprotocol::GuiRpSchema::declarations, object, field, value, cppFieldName); + case GuiRemoteProtocolFields::StructDecl_members: + return vl::glr::AssemblerSetObjectField(&vl::presentation::remoteprotocol::GuiRpStructDecl::members, object, field, value, cppFieldName); + case GuiRemoteProtocolFields::StructMember_type: + return vl::glr::AssemblerSetObjectField(&vl::presentation::remoteprotocol::GuiRpStructMember::type, object, field, value, cppFieldName); + default: + return vl::glr::AssemblyThrowFieldNotObject(field, cppFieldName); + } + } + + void GuiRemoteProtocolAstInsReceiver::SetField(vl::glr::ParsingAstBase* object, vl::vint32_t field, const vl::regex::RegexToken& token, vl::vint32_t tokenIndex) + { + auto cppFieldName = GuiRemoteProtocolCppFieldName((GuiRemoteProtocolFields)field); + switch((GuiRemoteProtocolFields)field) + { + case GuiRemoteProtocolFields::Attribute_cppType: + return vl::glr::AssemblerSetTokenField(&vl::presentation::remoteprotocol::GuiRpAttribute::cppType, object, field, token, tokenIndex, cppFieldName); + case GuiRemoteProtocolFields::Attribute_name: + return vl::glr::AssemblerSetTokenField(&vl::presentation::remoteprotocol::GuiRpAttribute::name, object, field, token, tokenIndex, cppFieldName); + case GuiRemoteProtocolFields::Declaration_name: + return vl::glr::AssemblerSetTokenField(&vl::presentation::remoteprotocol::GuiRpDeclaration::name, object, field, token, tokenIndex, cppFieldName); + case GuiRemoteProtocolFields::EnumMember_name: + return vl::glr::AssemblerSetTokenField(&vl::presentation::remoteprotocol::GuiRpEnumMember::name, object, field, token, tokenIndex, cppFieldName); + case GuiRemoteProtocolFields::ReferenceType_name: + return vl::glr::AssemblerSetTokenField(&vl::presentation::remoteprotocol::GuiRpReferenceType::name, object, field, token, tokenIndex, cppFieldName); + case GuiRemoteProtocolFields::StructMember_name: + return vl::glr::AssemblerSetTokenField(&vl::presentation::remoteprotocol::GuiRpStructMember::name, object, field, token, tokenIndex, cppFieldName); + default: + return vl::glr::AssemblyThrowFieldNotToken(field, cppFieldName); + } + } + + void GuiRemoteProtocolAstInsReceiver::SetField(vl::glr::ParsingAstBase* object, vl::vint32_t field, vl::vint32_t enumItem, bool weakAssignment) + { + auto cppFieldName = GuiRemoteProtocolCppFieldName((GuiRemoteProtocolFields)field); + switch((GuiRemoteProtocolFields)field) + { + case GuiRemoteProtocolFields::PrimitiveType_type: + return vl::glr::AssemblerSetEnumField(&vl::presentation::remoteprotocol::GuiRpPrimitiveType::type, object, field, enumItem, weakAssignment, cppFieldName); + default: + return vl::glr::AssemblyThrowFieldNotEnum(field, cppFieldName); + } + } + + const wchar_t* GuiRemoteProtocolTypeName(GuiRemoteProtocolClasses type) + { + const wchar_t* results[] = { + L"ArrayType", + L"Attribute", + L"Declaration", + L"EnumDecl", + L"EnumMember", + L"EventDecl", + L"EventRequest", + L"MessageDecl", + L"MessageRequest", + L"MessageResponse", + L"PrimitiveType", + L"ReferenceType", + L"Schema", + L"StructDecl", + L"StructMember", + L"Type", + }; + vl::vint index = (vl::vint)type; + return 0 <= index && index < 16 ? results[index] : nullptr; + } + + const wchar_t* GuiRemoteProtocolCppTypeName(GuiRemoteProtocolClasses type) + { + const wchar_t* results[] = { + L"vl::presentation::remoteprotocol::GuiRpArrayType", + L"vl::presentation::remoteprotocol::GuiRpAttribute", + L"vl::presentation::remoteprotocol::GuiRpDeclaration", + L"vl::presentation::remoteprotocol::GuiRpEnumDecl", + L"vl::presentation::remoteprotocol::GuiRpEnumMember", + L"vl::presentation::remoteprotocol::GuiRpEventDecl", + L"vl::presentation::remoteprotocol::GuiRpEventRequest", + L"vl::presentation::remoteprotocol::GuiRpMessageDecl", + L"vl::presentation::remoteprotocol::GuiRpMessageRequest", + L"vl::presentation::remoteprotocol::GuiRpMessageResponse", + L"vl::presentation::remoteprotocol::GuiRpPrimitiveType", + L"vl::presentation::remoteprotocol::GuiRpReferenceType", + L"vl::presentation::remoteprotocol::GuiRpSchema", + L"vl::presentation::remoteprotocol::GuiRpStructDecl", + L"vl::presentation::remoteprotocol::GuiRpStructMember", + L"vl::presentation::remoteprotocol::GuiRpType", + }; + vl::vint index = (vl::vint)type; + return 0 <= index && index < 16 ? results[index] : nullptr; + } + + const wchar_t* GuiRemoteProtocolFieldName(GuiRemoteProtocolFields field) + { + const wchar_t* results[] = { + L"ArrayType::element", + L"Attribute::cppType", + L"Attribute::name", + L"Declaration::attributes", + L"Declaration::name", + L"EnumDecl::members", + L"EnumMember::name", + L"EventDecl::request", + L"EventRequest::type", + L"MessageDecl::request", + L"MessageDecl::response", + L"MessageRequest::type", + L"MessageResponse::type", + L"PrimitiveType::type", + L"ReferenceType::name", + L"Schema::declarations", + L"StructDecl::members", + L"StructMember::name", + L"StructMember::type", + }; + vl::vint index = (vl::vint)field; + return 0 <= index && index < 19 ? results[index] : nullptr; + } + + const wchar_t* GuiRemoteProtocolCppFieldName(GuiRemoteProtocolFields field) + { + const wchar_t* results[] = { + L"vl::presentation::remoteprotocol::GuiRpArrayType::element", + L"vl::presentation::remoteprotocol::GuiRpAttribute::cppType", + L"vl::presentation::remoteprotocol::GuiRpAttribute::name", + L"vl::presentation::remoteprotocol::GuiRpDeclaration::attributes", + L"vl::presentation::remoteprotocol::GuiRpDeclaration::name", + L"vl::presentation::remoteprotocol::GuiRpEnumDecl::members", + L"vl::presentation::remoteprotocol::GuiRpEnumMember::name", + L"vl::presentation::remoteprotocol::GuiRpEventDecl::request", + L"vl::presentation::remoteprotocol::GuiRpEventRequest::type", + L"vl::presentation::remoteprotocol::GuiRpMessageDecl::request", + L"vl::presentation::remoteprotocol::GuiRpMessageDecl::response", + L"vl::presentation::remoteprotocol::GuiRpMessageRequest::type", + L"vl::presentation::remoteprotocol::GuiRpMessageResponse::type", + L"vl::presentation::remoteprotocol::GuiRpPrimitiveType::type", + L"vl::presentation::remoteprotocol::GuiRpReferenceType::name", + L"vl::presentation::remoteprotocol::GuiRpSchema::declarations", + L"vl::presentation::remoteprotocol::GuiRpStructDecl::members", + L"vl::presentation::remoteprotocol::GuiRpStructMember::name", + L"vl::presentation::remoteprotocol::GuiRpStructMember::type", + }; + vl::vint index = (vl::vint)field; + return 0 <= index && index < 19 ? results[index] : nullptr; + } + + vl::Ptr GuiRemoteProtocolAstInsReceiver::ResolveAmbiguity(vl::vint32_t type, vl::collections::Array>& candidates) + { + auto cppTypeName = GuiRemoteProtocolCppTypeName((GuiRemoteProtocolClasses)type); + return vl::glr::AssemblyThrowTypeNotAllowAmbiguity(type, cppTypeName); + } +} + + +/*********************************************************************** +.\REMOTEPROTOCOL\GENERATED\GUIREMOTEPROTOCOL_LEXER.CPP +***********************************************************************/ +/*********************************************************************** +This file is generated by: Vczh Parser Generator +From parser definition:GuiRemoteProtocol +Licensed under https://github.com/vczh-libraries/License +***********************************************************************/ + + +namespace vl::presentation::remoteprotocol +{ + bool GuiRemoteProtocolTokenDeleter(vl::vint token) + { + switch((GuiRemoteProtocolTokens)token) + { + case GuiRemoteProtocolTokens::SPACE: + return true; + default: + return false; + } + } + + const wchar_t* GuiRemoteProtocolTokenId(GuiRemoteProtocolTokens token) + { + static const wchar_t* results[] = { + L"VAR", + L"ENUM", + L"STRUCT", + L"MESSAGE", + L"REQUEST", + L"RESPONSE", + L"EVENT", + L"BOOLEAN", + L"INTEGER", + L"FLOAT", + L"DOUBLE", + L"STRING", + L"CHAR", + L"KEY", + L"CPP_NAME", + L"ATT_NAME", + L"NAME", + L"OPEN_BRACE", + L"CLOSE_BRACE", + L"OPEN_ARRAY", + L"CLOSE_ARRAY", + L"OPEN", + L"CLOSE", + L"COLON", + L"SEMICOLON", + L"COMMA", + L"SPACE", + }; + vl::vint index = (vl::vint)token; + return 0 <= index && index < GuiRemoteProtocolTokenCount ? results[index] : nullptr; + } + + const wchar_t* GuiRemoteProtocolTokenDisplayText(GuiRemoteProtocolTokens token) + { + static const wchar_t* results[] = { + L"var", + L"enum", + L"struct", + L"message", + L"request", + L"response", + L"event", + L"bool", + L"int", + L"float", + L"double", + L"string", + L"char", + L"key", + nullptr, + nullptr, + nullptr, + L"{", + L"}", + L"[", + L"]", + L"(", + L")", + L":", + L";", + L",", + nullptr, + }; + vl::vint index = (vl::vint)token; + return 0 <= index && index < GuiRemoteProtocolTokenCount ? results[index] : nullptr; + } + + const wchar_t* GuiRemoteProtocolTokenRegex(GuiRemoteProtocolTokens token) + { + static const wchar_t* results[] = { + L"var", + L"enum", + L"struct", + L"message", + L"request", + L"response", + L"event", + L"bool", + L"int", + L"float", + L"double", + L"string", + L"char", + L"key", + L"(::[a-zA-Z_][a-zA-Z0-9<>]*){1,}", + L"@[a-zA-Z_][a-zA-Z0-9]*", + L"[a-zA-Z_][a-zA-Z0-9]*", + L"/{", + L"/}", + L"/[", + L"/]", + L"/(", + L"/)", + L":", + L";", + L",", + L"/s+", + }; + vl::vint index = (vl::vint)token; + return 0 <= index && index < GuiRemoteProtocolTokenCount ? results[index] : nullptr; + } + + void GuiRemoteProtocolLexerData(vl::stream::IStream& outputStream) + { + static const vl::vint dataLength = 1555; // 16760 bytes before compressing + static const vl::vint dataBlock = 256; + static const vl::vint dataRemain = 19; + static const vl::vint dataSolidRows = 6; + static const vl::vint dataRows = 7; + static const char* compressed[] = { + "\x78\x41\x00\x00\x0B\x06\x00\x00\x59\x00\x01\xAD\x01\x84\x81\x80\x16\x82\x09\x08\x84\x8A\x0B\x84\x81\x06\x87\x04\xA0\x11\x84\x88\x14\x88\x83\x14\x17\x84\x87\x86\x84\x80\x18\x83\x1C\x04\xBA\x21\x84\x8B\x1C\x90\x82\x1E\x27\x84\xBE\x0A\x94\x80\x21\x96\x82\x41\x04\x9A\x24\x8B\x2C\x98\x83\x2E\x37\x84\x9F\x3A\x94\x81\x31\x9E\x82\x62\x40\x84\x83\x33\xA4\x80\x32\xA3\x04\xE5\x09\xA4\x86\x34\xA4\x83\x33\x4F\x84\xA8\x32\xA4\x81\x35\xAA\x82\x6A\x58\x84\x8B\x3B\xAC\x80\x36\xAF\x04\xED\x21\xA4\x8E\x34\xB0\x83\x37\x67\x84\xB0\x2A\xB4\x81\x39\xB6\x82\x72\x70\x84\x93\x33\xBC\x80\x3A\xBB\x04\xF5\x39\xA4\x86\x3C\xBC\x83\x3B\x04\xF8\x04\x99\x33\xC4\x82\x3C\xC3\x04\xFB\x09\xC4\x8D\x3C\xC4\x83\x0B\x8F\x91\xC1\x90\xC1\x83\x08\x82\x0A\x04\x96\x04\x9F\x7C\xCF\x7C\x06\x82\x15\x1B\xDD\xC3\xDF\x81\x82\x06\x82\x11\x04\x92\x04\x87\xD6\xD0\x82\x03\x0D\x81\x89\x81\x82\x04\x80\x04\xD6\xB8\x81\x87\x19\xD0\x03\x04\xDE\x02\xBC\xAD\xC0\x02\xE2\xE5\x00\x83\x01\xC1\x84\x81\x09\xEE\xD1\x83\x06\x82\x10\x22\xE3\xD3\xE4\xED\xEA\xEB\x0C\xD2\xD6\xDA\xF8", + "\xE1\x82\xED\xCE\x0C\x04\xDC\xC0\x02\xF4\xF1\xF2\xF3\x80\xE5\xE8\xE7\xE3\xFB\xF1\xF4\xF6\xF5\xF0\xEF\xF2\xEE\xF4\xF9\xEE\xEF\xFB\xF8\x9D\xE2\xF9\xF5\xEB\xFF\xFB\xFA\xF1\x40\x83\x7D\x7B\x04\x81\x4A\x05\x81\x03\x81\x8B\x7B\x06\x08\xBE\x7C\x7F\x83\xDB\x76\x7F\x82\x83\x11\x8A\x86\x85\x82\x18\x82\x8A\x85\x83\x04\x5C\x0C\x87\x85\x10\xA1\x8D\x7E\x84\xFC\x54\x87\x77\x87\x00\x1D\x08\x8B\x86\x17\xAC\x89\x87\x8A\x24\xA2\x83\x85\x8C\xF8\x66\x83\x89\x8B\x04\x5E\x00\x8C\x8E\x3C\xAF\x8D\x8E\x8B\x32\x81\x9F\x3E\x8D\x25\xB4\x8A\x7F\x8E\x3E\x89\x92\x83\x07\x48\xAE\x8E\x7A\x90\x32\x84\x99\x7E\x94\xA3\x4E\x9D\x90\x8A\x12\x7F\x87\x94\x88\x50\xA1\x84\x97\x7F\x46\x9C\x66\x96\x96\x17\xA1\x0B\x96\x92\x48\x9D\x9E\x95\x98\x15\x80\x05\x8F\x99\x63\x89\x92\x08\x9C\x69\xAA\x93\x8D\x77\x51\xAC\x91\x9E\x7B\x23\x34\x94\x98\x9A\x3D\xB6\x97\x9E\x9B\x79\xB8\x9E\x76\x8B\x24\x3E\x90\xA3\xA2\x7B\xAC\x92\xA0\x75\x25\x0E\xAF\xA3\xA4\x94\x95\xA6\xA7\xA5\xD4\x66\x01\x8E\xA6\x01\x5C\xA0\x02\xA7\xA0\x84\x41\xA9\xA7\xA2\xA5\xA4\xAB\xA9\x9F\xA6\xA9\xA8\xAA", + "\xA3\xAB\xAE\xA9\xAB\xB0\xAA\xA8\xA7\x8D\x84\xA2\x8F\x96\x98\x8A\x8D\xAF\x9E\xAE\x18\xB3\xAE\xAF\xAF\xC0\x81\xB2\xB3\xB0\xC4\x85\xB6\xB3\xB1\xC8\x89\xBA\xB3\xB2\xCC\x8D\xBE\xB3\xB3\xD0\x91\xB2\xB7\xB4\xD4\x95\xB6\xB7\xB5\xD8\x99\xB7\xB7\x09\x04\x5C\xB1\x42\xB7\x00\x20\xBA\xB7\xB8\xE4\xB7\xAD\x9B\x9B\xBB\xB9\xA8\x91\x45\xE9\x9C\x91\xB2\xB9\x27\x86\xAD\x98\xAF\xF4\xAA\xBF\x9F\xB0\xF0\xB4\xA8\xB8\xA3\xF6\xBC\xB7\x84\x46\xF7\x82\xB9\xBC\x75\xE6\xAE\x8A\x09\xBF\xF5\xAD\xB2\x7C\xBE\x92\x84\xCA\x9C\xC2\x10\xC1\x4B\x09\xBF\x0C\xF2\xB0\x85\xC1\x11\xFE\xBB\xA3\x46\x1A\xC3\xC6\x9E\xC7\x55\x8F\xCA\xC1\xC2\x49\x83\x41\x7E\x0B\x8A\x95\xC5\xAF\x9A\x16\xF4\xA4\xC8\xAF\x2F\x19\xCF\x92\xC0\x0D\xD3\x78\xC7\xC8\x32\xE8\x8E\x46\xC2\x2A\xC1\x97\xCD\xC7\xFD\xB1\x09\xCD\x7C\x3D\xC5\xAB\xC9\xBC\x40\xF8\xCA\xD2\x7C\x32\x35\x9F\xB9\xCD\x21\xED\xC4\x77\x0C\x43\xC9\xD6\xD6\x80\x45\xF6\xA2\xCB\xD5\x55\xFC\xA4\x0F\x7A\xE3\xB5\x01\x8E\xD8\x01\x64\xD0\x02\xD9\x68\xC4\x49\xD9\xD9\x6A\xED\xDC\xDB\xDB\x67\xEE\xD1\xDC\xDC\x6B\xF3\xD6\xDD\xDD\x78", + "\xF2\xD3\xB2\x0D\x50\xDD\x6C\xDE\xD4\xD3\x7F\xD0\x02\xE0\x84\xC4\x45\xE1\x40\x87\xC3\xE6\xE3\xE2\x88\xCC\xEA\xE1\xE3\x90\xCF\xE2\xE5\xE2\x94\xCE\xE2\xE0\x7E\xE0\x99\xED\xB5\xDF\xE4\x9D\xE6\xB0\xC8\x47\x80\xE1\xD4\xD7\x4B\xEF\xC8\x89\xD6\x2C\xC7\xDE\xC9\xD7\x04\x77\x0C\xEA\xBB\xC0\xA0\xE8\xAE\xE8\xA1\xE4\xEA\xC4\x0E\xAF\xCB\xC4\xCC\xED\x87\x9B\xD4\xCA\x48\xA5\xC8\x90\x49\xC0\x4F\xFC\xE7\xB8\x98\xC1\xC9\xF9\x91\x49\x4B\xE8\xE7\xC6\xEF\xB9\xE6\xE1\x40\x4A\xC4\xF1\xEC\xE7\x90\xD0\xCA\xFC\xAD\x0F\x55\xCE\xF3\xA3\xBE\xD2\xD8\x8B\x4A\xF6\x67\x9E\xF5\x92\xF1\xE1\xE9\xF9\xC6\xF9\x53\xAC\x9F\x0D\xF4\xF0\xF0\xEF\xAE\xEC\xD8\xE8\xFF\x48\xF9\xF8\xF6\xEC\xFB\xBE\xE0\xF1\xFB\xA1\x4C\xCA\x7B\x7C\xF2\x2A\x7E\x61\xFC\x6A\x79\x80\xC2\x42\x08\x41\x43\x09\x3A\x05\x81\x26\x81\x2B\x70\x80\x7E\x10\x84\x82\x82\x15\x87\x81\x16\x99\x80\x06\x9B\x80\x01\x0B\x9D\x82\x83\x1F\x9C\x82\x07\xA3\x80\x84\x12\x86\x7B\x52\x97\x72\x45\x0A\xDE\x35\x73\xC8\x6D\x83\x72\x96\x71\x86\x0B\xB2\x80\x87\x19\xB6\x85\x86\x04\x98\x50\xFD\x3F\x67\x80\xDB\x61\x7A", + "\x80\xBD\x76\x7E\x01\xD5\x64\x09\xF2\x7B\x71\x87\xFC\x63\x82\x78\x45\x0E\x7F\x1E\xB3\x65\x78\x48\x83\x81\xFF\x43\x87\x42\x23\x3E\x78\x88\xC7\x7E\x3B\x11\x4D\x8C\x8B\x13\x8F\x53\x87\xD9\x78\x40\x12\x5D\x8E\x87\xEB\x7E\x67\x7A\x3C\x84\x8D\x12\x39\x78\x8A\xA4\x53\x8D\x8C\x54\x96\x69\x1B\xFA\x5A\x88\x32\xB1\x4A\x09\x46\x90\x8B\x19\xC2\x80\x8E\x0C\x4B\x0E\x8E\x66\x86\x6B\x1E\xD1\x83\x77\x3E\x8E\x89\x65\x09\x8B\x81\x03\xA0\x83\x34\x09\xB7\x3E\x84\x21\x91\x90\x24\x93\x95\x85\x4A\xA2\x86\x92\x92\x98\x92\x23\xC5\x5C\x09\x40\x9E\x77\x93\xDF\x62\x91\x1D\xF1\x87\x91\xEA\x73\x78\x8D\x61\x85\x96\xED\x4D\x09\x8E\xEB\x5E\x8D\x80\x84\x95\x7E\xC6\x4E\x00\x90\x9E\x47\x8B\x90\x6F\x8E\x47\x13\x35\x9A\x63\x39\xB0\x91\x97\xBC\x8E\x3C\x14\x08\x9A\x8E\x51\x81\x8E\x90\x28\x51\x0B\x15\xB7\x96\x99\x79\x41\x9D\x7B\xCC\x9A\x68\x1F\x82\x42\x0B\x67\x8D\x7A\x5B\x53\x11\x45\x36\x81\x2B\x9A\x00\x1D\x9F\x9B\x04\x20\x9C\x37\xE1\x94\x9D\x71\xA6\x9E\x9B\xE5\x88\x9F\x39\xE2\x9A\x9D\x76\xAC\x9F\x9D\xE9\x9E\x96\xCD\x29\x96\x9B\x3E\xB2\x9B\x74\xC0\x84", + "\x94\x19\xF7\x95\x77\x7C\xB2\x3C\x0A\xF5\x9C\x54\x3F\x85\x9E\x9E\x55\xBC\x55\x0A\xAD\x87\x97\x2B\xF3\x93\x9B\x80\xAB\x3E\x0A\xC4\x8E\x95\x2C\xEE\x83\x94\x64\xBA\x9E\x94\xBE\x57\x0A\x22\xF2\x5A\xA3\x80\x1D\xA3\x65\x1F\xB8\x3F\x47\xA3\xA4\x20\x92\x9E\xA5\xA4\x28\xA7\xA6\x4A\x80\x06\xA4\x96\xA9\xA6\xA5\x2B\xAD\xA6\x4C\xAF\xA3\xA7\x85\xAA\x48\x8C\x0D\xB7\xA2\x45\x8B\x53\xA0\x59\x85\xA6\xA1\xD7\x85\x9A\x34\xB1\x9E\x44\x2C\x00\xAD\x97\xC2\x5F\xA0\x03\x9C\xAF\xA5\xD1\x21\xA7\x3E\x35\xB0\xA6\x54\xD1\xA4\xAA\x9A\x96\xA9\xA6\x57\xB3\xA9\x56\xCF\xA2\xA9\xD4\x7F\xA2\xA7\x06\xAC\x4E\x3F\x5F\x1C\x32\xB2\x9C\x37\x1E\xEF\x1F\x1D\x00\x00\x25\x21\x80\x11\x3E\xAD\xD0\x31\xAC\x5C\xF3\xA0\x01\xB7\xB5\xAA\xAE\x77\xB4\xAC\x65\x00\x0C\x40\xBA\xA9\x31\x20\xAB\x35\x33\x65\x20\x39\x32\x82\x20\x39\x3E\x07\x54\xAE\x5D\x8B\xB8\xAE\xC6\x8A\xB5\xB1\x90\xA1\x21\x5F\x80\x0F\x38\x03\x6D\xAF\xB1\x98\xB9\xAE\x66\xF6\xA7\x37\xCC\xB6\xAD\x34\xC3\x24\x21\x65\x80\x0B\x38\xCF\x91\xB2\xB3\xBB\x39\xB3\x67\x4D\x3C\xAF\xD7\x27\xB6\xB1\x9A\xB3\x36\x66\x93", + "\xB5\x37\x80\x3E\x36\xB4\x01\x2C\x20\x6B\xC8\x31\x20\xE0\x34\xAD\x38\x04\x20", + }; + vl::glr::DecompressSerializedData(compressed, true, dataSolidRows, dataRows, dataBlock, dataRemain, outputStream); + } +} + + /*********************************************************************** .\WORKFLOWCODEGEN\GUIINSTANCELOADER_WORKFLOWCODEGEN.CPP ***********************************************************************/ diff --git a/Import/GacUICompiler.h b/Import/GacUICompiler.h index 513779cb..fd3386e5 100644 --- a/Import/GacUICompiler.h +++ b/Import/GacUICompiler.h @@ -1057,6 +1057,557 @@ namespace vl #endif +/*********************************************************************** +.\REMOTEPROTOCOL\GENERATED\GUIREMOTEPROTOCOLAST.H +***********************************************************************/ +/*********************************************************************** +This file is generated by: Vczh Parser Generator +From parser definition:Ast +Licensed under https://github.com/vczh-libraries/License +***********************************************************************/ + +#ifndef VCZH_PRESENTATION_REMOTEPROTOCOL_AST_AST +#define VCZH_PRESENTATION_REMOTEPROTOCOL_AST_AST + + +namespace vl::presentation::remoteprotocol +{ + class GuiRpArrayType; + class GuiRpAttribute; + class GuiRpDeclaration; + class GuiRpEnumDecl; + class GuiRpEnumMember; + class GuiRpEventDecl; + class GuiRpEventRequest; + class GuiRpMessageDecl; + class GuiRpMessageRequest; + class GuiRpMessageResponse; + class GuiRpPrimitiveType; + class GuiRpReferenceType; + class GuiRpSchema; + class GuiRpStructDecl; + class GuiRpStructMember; + class GuiRpType; + + enum class GuiRpPrimitiveTypes + { + UNDEFINED_ENUM_ITEM_VALUE = -1, + Boolean = 0, + Integer = 1, + Float = 2, + Double = 3, + String = 4, + Char = 5, + Key = 6, + }; + + class GuiRpType abstract : public vl::glr::ParsingAstBase, vl::reflection::Description + { + public: + class IVisitor : public virtual vl::reflection::IDescriptable, vl::reflection::Description + { + public: + virtual void Visit(GuiRpPrimitiveType* node) = 0; + virtual void Visit(GuiRpReferenceType* node) = 0; + virtual void Visit(GuiRpArrayType* node) = 0; + }; + + virtual void Accept(GuiRpType::IVisitor* visitor) = 0; + + }; + + class GuiRpPrimitiveType : public GuiRpType, vl::reflection::Description + { + public: + GuiRpPrimitiveTypes type = GuiRpPrimitiveTypes::UNDEFINED_ENUM_ITEM_VALUE; + + void Accept(GuiRpType::IVisitor* visitor) override; + }; + + class GuiRpReferenceType : public GuiRpType, vl::reflection::Description + { + public: + vl::glr::ParsingToken name; + + void Accept(GuiRpType::IVisitor* visitor) override; + }; + + class GuiRpArrayType : public GuiRpType, vl::reflection::Description + { + public: + vl::Ptr element; + + void Accept(GuiRpType::IVisitor* visitor) override; + }; + + class GuiRpAttribute : public vl::glr::ParsingAstBase, vl::reflection::Description + { + public: + vl::glr::ParsingToken name; + vl::glr::ParsingToken cppType; + }; + + class GuiRpDeclaration abstract : public vl::glr::ParsingAstBase, vl::reflection::Description + { + public: + class IVisitor : public virtual vl::reflection::IDescriptable, vl::reflection::Description + { + public: + virtual void Visit(GuiRpEnumDecl* node) = 0; + virtual void Visit(GuiRpStructDecl* node) = 0; + virtual void Visit(GuiRpMessageDecl* node) = 0; + virtual void Visit(GuiRpEventDecl* node) = 0; + }; + + virtual void Accept(GuiRpDeclaration::IVisitor* visitor) = 0; + + vl::collections::List> attributes; + vl::glr::ParsingToken name; + }; + + class GuiRpEnumMember : public vl::glr::ParsingAstBase, vl::reflection::Description + { + public: + vl::glr::ParsingToken name; + }; + + class GuiRpEnumDecl : public GuiRpDeclaration, vl::reflection::Description + { + public: + vl::collections::List> members; + + void Accept(GuiRpDeclaration::IVisitor* visitor) override; + }; + + class GuiRpStructMember : public vl::glr::ParsingAstBase, vl::reflection::Description + { + public: + vl::glr::ParsingToken name; + vl::Ptr type; + }; + + class GuiRpStructDecl : public GuiRpDeclaration, vl::reflection::Description + { + public: + vl::collections::List> members; + + void Accept(GuiRpDeclaration::IVisitor* visitor) override; + }; + + class GuiRpMessageRequest : public vl::glr::ParsingAstBase, vl::reflection::Description + { + public: + vl::Ptr type; + }; + + class GuiRpMessageResponse : public vl::glr::ParsingAstBase, vl::reflection::Description + { + public: + vl::Ptr type; + }; + + class GuiRpMessageDecl : public GuiRpDeclaration, vl::reflection::Description + { + public: + vl::Ptr request; + vl::Ptr response; + + void Accept(GuiRpDeclaration::IVisitor* visitor) override; + }; + + class GuiRpEventRequest : public vl::glr::ParsingAstBase, vl::reflection::Description + { + public: + vl::Ptr type; + }; + + class GuiRpEventDecl : public GuiRpDeclaration, vl::reflection::Description + { + public: + vl::Ptr request; + + void Accept(GuiRpDeclaration::IVisitor* visitor) override; + }; + + class GuiRpSchema : public vl::glr::ParsingAstBase, vl::reflection::Description + { + public: + vl::collections::List> declarations; + }; +} +namespace vl::reflection::description +{ +#ifndef VCZH_DEBUG_NO_REFLECTION + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpType) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpType::IVisitor) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpPrimitiveTypes) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpPrimitiveType) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpReferenceType) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpArrayType) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpAttribute) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpDeclaration) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpDeclaration::IVisitor) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpEnumMember) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpEnumDecl) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpStructMember) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpStructDecl) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpMessageRequest) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpMessageResponse) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpMessageDecl) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpEventRequest) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpEventDecl) + DECL_TYPE_INFO(vl::presentation::remoteprotocol::GuiRpSchema) + +#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA + + BEGIN_INTERFACE_PROXY_NOPARENT_SHAREDPTR(vl::presentation::remoteprotocol::GuiRpType::IVisitor) + void Visit(vl::presentation::remoteprotocol::GuiRpPrimitiveType* node) override + { + INVOKE_INTERFACE_PROXY(Visit, node); + } + + void Visit(vl::presentation::remoteprotocol::GuiRpReferenceType* node) override + { + INVOKE_INTERFACE_PROXY(Visit, node); + } + + void Visit(vl::presentation::remoteprotocol::GuiRpArrayType* node) override + { + INVOKE_INTERFACE_PROXY(Visit, node); + } + + END_INTERFACE_PROXY(vl::presentation::remoteprotocol::GuiRpType::IVisitor) + + BEGIN_INTERFACE_PROXY_NOPARENT_SHAREDPTR(vl::presentation::remoteprotocol::GuiRpDeclaration::IVisitor) + void Visit(vl::presentation::remoteprotocol::GuiRpEnumDecl* node) override + { + INVOKE_INTERFACE_PROXY(Visit, node); + } + + void Visit(vl::presentation::remoteprotocol::GuiRpStructDecl* node) override + { + INVOKE_INTERFACE_PROXY(Visit, node); + } + + void Visit(vl::presentation::remoteprotocol::GuiRpMessageDecl* node) override + { + INVOKE_INTERFACE_PROXY(Visit, node); + } + + void Visit(vl::presentation::remoteprotocol::GuiRpEventDecl* node) override + { + INVOKE_INTERFACE_PROXY(Visit, node); + } + + END_INTERFACE_PROXY(vl::presentation::remoteprotocol::GuiRpDeclaration::IVisitor) + +#endif +#endif + /// Load all reflectable AST types, only available when VCZH_DEBUG_NO_REFLECTION is off. + /// Returns true if this operation succeeded. + extern bool GuiRemoteProtocolAstLoadTypes(); +} +#endif + +/*********************************************************************** +.\REMOTEPROTOCOL\GENERATED\GUIREMOTEPROTOCOLAST_JSON.H +***********************************************************************/ +/*********************************************************************** +This file is generated by: Vczh Parser Generator +From parser definition:Ast +Licensed under https://github.com/vczh-libraries/License +***********************************************************************/ + +#ifndef VCZH_PRESENTATION_REMOTEPROTOCOL_AST_AST_JSON_VISITOR +#define VCZH_PRESENTATION_REMOTEPROTOCOL_AST_AST_JSON_VISITOR + + +namespace vl::presentation::remoteprotocol::json_visitor +{ + /// A JSON visitor, overriding all abstract methods with AST to JSON serialization code. + class AstVisitor + : public vl::glr::JsonVisitorBase + , protected virtual GuiRpType::IVisitor + , protected virtual GuiRpDeclaration::IVisitor + { + protected: + virtual void PrintFields(GuiRpArrayType* node); + virtual void PrintFields(GuiRpAttribute* node); + virtual void PrintFields(GuiRpDeclaration* node); + virtual void PrintFields(GuiRpEnumDecl* node); + virtual void PrintFields(GuiRpEnumMember* node); + virtual void PrintFields(GuiRpEventDecl* node); + virtual void PrintFields(GuiRpEventRequest* node); + virtual void PrintFields(GuiRpMessageDecl* node); + virtual void PrintFields(GuiRpMessageRequest* node); + virtual void PrintFields(GuiRpMessageResponse* node); + virtual void PrintFields(GuiRpPrimitiveType* node); + virtual void PrintFields(GuiRpReferenceType* node); + virtual void PrintFields(GuiRpSchema* node); + virtual void PrintFields(GuiRpStructDecl* node); + virtual void PrintFields(GuiRpStructMember* node); + virtual void PrintFields(GuiRpType* node); + + protected: + void Visit(GuiRpPrimitiveType* node) override; + void Visit(GuiRpReferenceType* node) override; + void Visit(GuiRpArrayType* node) override; + + void Visit(GuiRpEnumDecl* node) override; + void Visit(GuiRpStructDecl* node) override; + void Visit(GuiRpMessageDecl* node) override; + void Visit(GuiRpEventDecl* node) override; + + public: + AstVisitor(vl::stream::StreamWriter& _writer); + + void Print(GuiRpType* node); + void Print(GuiRpDeclaration* node); + void Print(GuiRpAttribute* node); + void Print(GuiRpEnumMember* node); + void Print(GuiRpStructMember* node); + void Print(GuiRpMessageRequest* node); + void Print(GuiRpMessageResponse* node); + void Print(GuiRpEventRequest* node); + void Print(GuiRpSchema* node); + }; +} +#endif + +/*********************************************************************** +.\REMOTEPROTOCOL\GENERATED\GUIREMOTEPROTOCOL_ASSEMBLER.H +***********************************************************************/ +/*********************************************************************** +This file is generated by: Vczh Parser Generator +From parser definition:GuiRemoteProtocol +Licensed under https://github.com/vczh-libraries/License +***********************************************************************/ + +#ifndef VCZH_PRESENTATION_REMOTEPROTOCOL_AST_ASSEMBLER +#define VCZH_PRESENTATION_REMOTEPROTOCOL_AST_ASSEMBLER + + +namespace vl::presentation::remoteprotocol +{ + enum class GuiRemoteProtocolClasses : vl::vint32_t + { + ArrayType = 0, + Attribute = 1, + Declaration = 2, + EnumDecl = 3, + EnumMember = 4, + EventDecl = 5, + EventRequest = 6, + MessageDecl = 7, + MessageRequest = 8, + MessageResponse = 9, + PrimitiveType = 10, + ReferenceType = 11, + Schema = 12, + StructDecl = 13, + StructMember = 14, + Type = 15, + }; + + enum class GuiRemoteProtocolFields : vl::vint32_t + { + ArrayType_element = 0, + Attribute_cppType = 1, + Attribute_name = 2, + Declaration_attributes = 3, + Declaration_name = 4, + EnumDecl_members = 5, + EnumMember_name = 6, + EventDecl_request = 7, + EventRequest_type = 8, + MessageDecl_request = 9, + MessageDecl_response = 10, + MessageRequest_type = 11, + MessageResponse_type = 12, + PrimitiveType_type = 13, + ReferenceType_name = 14, + Schema_declarations = 15, + StructDecl_members = 16, + StructMember_name = 17, + StructMember_type = 18, + }; + + extern const wchar_t* GuiRemoteProtocolTypeName(GuiRemoteProtocolClasses type); + extern const wchar_t* GuiRemoteProtocolCppTypeName(GuiRemoteProtocolClasses type); + extern const wchar_t* GuiRemoteProtocolFieldName(GuiRemoteProtocolFields field); + extern const wchar_t* GuiRemoteProtocolCppFieldName(GuiRemoteProtocolFields field); + + class GuiRemoteProtocolAstInsReceiver : public vl::glr::AstInsReceiverBase + { + protected: + vl::Ptr CreateAstNode(vl::vint32_t type) override; + void SetField(vl::glr::ParsingAstBase* object, vl::vint32_t field, vl::Ptr value) override; + void SetField(vl::glr::ParsingAstBase* object, vl::vint32_t field, const vl::regex::RegexToken& token, vl::vint32_t tokenIndex) override; + void SetField(vl::glr::ParsingAstBase* object, vl::vint32_t field, vl::vint32_t enumItem, bool weakAssignment) override; + vl::Ptr ResolveAmbiguity(vl::vint32_t type, vl::collections::Array>& candidates) override; + }; +} +#endif + +/*********************************************************************** +.\REMOTEPROTOCOL\GENERATED\GUIREMOTEPROTOCOL_LEXER.H +***********************************************************************/ +/*********************************************************************** +This file is generated by: Vczh Parser Generator +From parser definition:GuiRemoteProtocol +Licensed under https://github.com/vczh-libraries/License +***********************************************************************/ + +#ifndef VCZH_PRESENTATION_REMOTEPROTOCOL_LEXER +#define VCZH_PRESENTATION_REMOTEPROTOCOL_LEXER + + +namespace vl::presentation::remoteprotocol +{ + enum class GuiRemoteProtocolTokens : vl::vint32_t + { + VAR = 0, + ENUM = 1, + STRUCT = 2, + MESSAGE = 3, + REQUEST = 4, + RESPONSE = 5, + EVENT = 6, + BOOLEAN = 7, + INTEGER = 8, + FLOAT = 9, + DOUBLE = 10, + STRING = 11, + CHAR = 12, + KEY = 13, + CPP_NAME = 14, + ATT_NAME = 15, + NAME = 16, + OPEN_BRACE = 17, + CLOSE_BRACE = 18, + OPEN_ARRAY = 19, + CLOSE_ARRAY = 20, + OPEN = 21, + CLOSE = 22, + COLON = 23, + SEMICOLON = 24, + COMMA = 25, + SPACE = 26, + }; + + constexpr vl::vint GuiRemoteProtocolTokenCount = 27; + extern bool GuiRemoteProtocolTokenDeleter(vl::vint token); + extern const wchar_t* GuiRemoteProtocolTokenId(GuiRemoteProtocolTokens token); + extern const wchar_t* GuiRemoteProtocolTokenDisplayText(GuiRemoteProtocolTokens token); + extern const wchar_t* GuiRemoteProtocolTokenRegex(GuiRemoteProtocolTokens token); + extern void GuiRemoteProtocolLexerData(vl::stream::IStream& outputStream); +} +#endif + +/*********************************************************************** +.\REMOTEPROTOCOL\GENERATED\GUIREMOTEPROTOCOLPARSER.H +***********************************************************************/ +/*********************************************************************** +This file is generated by: Vczh Parser Generator +From parser definition:GuiRemoteProtocol +Licensed under https://github.com/vczh-libraries/License +***********************************************************************/ + +#ifndef VCZH_PRESENTATION_REMOTEPROTOCOL_PARSER_SYNTAX +#define VCZH_PRESENTATION_REMOTEPROTOCOL_PARSER_SYNTAX + + +namespace vl::presentation::remoteprotocol +{ + enum class ParserStates + { + RType = 0, + RAttributeParameter = 13, + RAttribute = 16, + REnumMember = 24, + REnum = 28, + RStructMember = 35, + RStruct = 42, + RMessageRequest = 49, + RMessageResponse = 55, + RMessage = 61, + REventRequest = 69, + REvent = 75, + RDeclDetail = 82, + RDecl = 88, + Schema = 92, + }; + + const wchar_t* ParserRuleName(vl::vint index); + const wchar_t* ParserStateLabel(vl::vint index); + extern void GuiRemoteProtocolParserData(vl::stream::IStream& outputStream); + + class Parser + : public vl::glr::ParserBase + , protected vl::glr::automaton::IExecutor::ITypeCallback + { + protected: + vl::WString GetClassName(vl::vint32_t classIndex) const override; + vl::vint32_t FindCommonBaseClass(vl::vint32_t class1, vl::vint32_t class2) const override; + public: + Parser(); + + vl::Ptr ParseSchema(const vl::WString& input, vl::vint codeIndex = -1) const; + vl::Ptr ParseSchema(vl::collections::List& tokens, vl::vint codeIndex = -1) const; + }; +} +#endif + +/*********************************************************************** +.\REMOTEPROTOCOL\GUIREMOTEPROTOCOLCOMPILER.H +***********************************************************************/ +/*********************************************************************** +Vczh Library++ 3.0 +Developer: Zihan Chen(vczh) +GacUI Reflection: Remote Protocol + +Interfaces: +***********************************************************************/ + +#ifndef VCZH_PRESENTATION_REFLECTION_REMOTEPROTOCOL_GUIREMOTEPROTOCOL +#define VCZH_PRESENTATION_REFLECTION_REMOTEPROTOCOL_GUIREMOTEPROTOCOL + + +namespace vl::presentation +{ + struct GuiRpError + { + glr::ParsingTextRange position; + WString errorMessage; + }; + + struct GuiRpSymbols + { + collections::Dictionary cppMapping; + collections::SortedList dropRepeatDeclNames; + collections::SortedList dropConsecutiveDeclNames; + collections::Dictionary enumDecls; + collections::Dictionary structDecls; + collections::Dictionary messageDecls; + collections::Dictionary eventDecls; + }; + + struct GuiRpCppConfig + { + WString headerFileName; + WString headerGuard; + WString headerInclude; + WString cppNamespace; + WString builderMacroPrefix; + }; + + extern Ptr CheckRemoteProtocolSchema(Ptr schema, collections::List& errors); + extern void GenerateRemoteProtocolHeaderFile(Ptr schema, Ptr symbols, GuiRpCppConfig& config, stream::TextWriter& writer); + extern void GenerateRemoteProtocolCppFile(Ptr schema, Ptr symbols, GuiRpCppConfig& config, stream::TextWriter& writer); +} + +#endif + /*********************************************************************** .\WORKFLOWCODEGEN\GUIINSTANCELOADER_WORKFLOWCODEGEN.H ***********************************************************************/ diff --git a/Import/VlppReflection.cpp b/Import/VlppReflection.cpp index 293ae195..02b0185c 100644 --- a/Import/VlppReflection.cpp +++ b/Import/VlppReflection.cpp @@ -4555,7 +4555,6 @@ Author: Zihan Chen (vczh) Licensed under https://github.com/vczh-libraries/License ***********************************************************************/ -#include namespace vl { diff --git a/Import/VlppReflection.h b/Import/VlppReflection.h index 4589f990..cac87bf0 100644 --- a/Import/VlppReflection.h +++ b/Import/VlppReflection.h @@ -2832,9 +2832,8 @@ Licensed under https://github.com/vczh-libraries/License #ifndef VCZH_REFLECTION_TYPES_TYPEDVALUESERIALIZERPROVIDER #define VCZH_REFLECTION_TYPES_TYPEDVALUESERIALIZERPROVIDER -#ifdef VCZH_GCC +#include #include -#endif namespace vl { diff --git a/Tools/Reflection32.bin b/Tools/Reflection32.bin index 3f650e93662bc701facd81b8d91c48bf6161e3ea..d071f5f8edae788dd4bc6353247eb8f120e15ba5 100644 GIT binary patch delta 34624 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 delta 34147 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 delta 34147 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

S#IvRpZ3NMn;=noYc7~or8*cVgo@V*E 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 S2J`RGYrv*6nX_Kqwf+Ir&=Bwd diff --git a/Tutorial/GacUI_ControlTemplate/UIRes/BlackSkin.bin b/Tutorial/GacUI_ControlTemplate/UIRes/BlackSkin.bin index f19022c047095dc79a3cbd073f1ce3d12b271a53..7548d75c2fb4c131261afd0beb606c7cbed5176f 100644 GIT binary patch delta 64 zcmex=n|1js)(uS0ICK~wU~<52k7(oC4 delta 37 pcmZ4fiuM0()(uS0IJ6lcU~<52k%o$1?BrVSUFIdm8xV6vcz$mX}q)5RsZp&}sKB{e6tB-JOeC_R;xeey(gwax33 QUb0PoFUYfbg0x)$0HNX(LI3~& delta 25 hcmeyil1Eax*{xh;~WMNi9kBNi0fFWo4i27^Sw^H2EdlWW8pd J&0;ck1poqG5e)zU delta 32 jcmeyfjOoe@rVZgN9NG*JF!_P6$mU{}>EfG>l)VZ7sbdMh diff --git a/Tutorial/GacUI_Controls/UIRes/DocumentEditorToolstrip.bin b/Tutorial/GacUI_Controls/UIRes/DocumentEditorToolstrip.bin index cb82986a917b399fa03bea58cb7ebc757fd9c9cd..c0054653581641b1dce513bec0299291c378d601 100644 GIT binary patch delta 75 zcmdlugX!inrVS=696AgTFnM96$mRf+>Ee>yP!SOAlA4oRlIoLKl%C4UK3TC@bn<^$ U!OcR+FWDw@H}h=%ENxc+0KWSamjD0& delta 32 jcmcb)jA`QxrVS=69NG*JF!=(P$mRf+>EfIDmAwi8m*xn) diff --git a/Tutorial/GacUI_Controls/UIRes/Win11ToolstripMenu.bin b/Tutorial/GacUI_Controls/UIRes/Win11ToolstripMenu.bin index 6072a5b404ce6191fb89fccab37738f6cdf5adce..9ffc0fd69e464ffbcfb5592da372ae39d51506f1 100644 GIT binary patch delta 60 zcmZ2BmFe7KrVZ>&j5?b+m^O(^ax*{xh;~WMNi9kBNi0fFWo4iIF&9NG*JFnNNv$Yy1x>EfFoDZD8F0Fti>wg3PC diff --git a/Tutorial/GacUI_HelloWorlds/UIRes/Xml.bin.x64 b/Tutorial/GacUI_HelloWorlds/UIRes/Xml.bin.x64 index 9a9b30b2e83b634714cc4c582a4523d446d11e75..4f22d1117e01d52179f2ff904bd894fc7d8cb864 100644 GIT binary patch delta 777 zcma)3OH30{6z!Yuo3@mPzYa#)p(Y{+F*}YB#cTK zqdT&>y7A;(FTN*C^vf2mM&nSG9eA#eU`gr6EhT4U!^|u!C53CGCY6II$a}Fk)CO6# zQBXSv+rz8?Yjd^w)NDR~s#=|y@+PCXM)k8uaL(G$&im=Y2t^6A zyocff&r$r$GZY&PGSDG`dsHuNj?X@6$guL-bN7ZXUwk}LwI?UZh8!dwe} zEG^{%2<(Z-1M3p~q2%(%*q<}_RT3zW#hPovq{kX^E$s6+*2)}`W5Uunnv((*hvQCB zFd46$G=+SpgA&&|F$({a3<#FEZ&+U>(_N8lt)@{TZdk>f?#Mz41PanGcw ytniGcq7DN06n#&@X8)ZuzkX;U281y||>Fz`DACJWuFWsPkF)$`k60w^S;_2#;Z#kKiRw zqY|FSm+-Ov13_IItMzKFw35qBuh!0(b0iv$ zz?PQBrYn(%n21S%@yM)?#YjIkB3FeB#PCzi`iaY$(3K#lV@Qj`J|yv}D9|TPGKq1K zW&$f>nCx>gLiU?Tl5LWWz|d1n!y|o8j|3VTG5RpAk0tdWqITi%jauby;D=h6G%VHv zH_l^{U5f^f==fjK*0QceGxm-hulq zc+o*6+ksPUu#}d9D_VTxbM(&)?1I3QXJVIb@7IEaNw+!bSQscsD7HyzTXr0)w!o7G z+2y?poVT6f^Mj`Y6785+5-BeI!7K-zwReUig@W<@IwHZN&mBhIf$G-K1Y5kbA2Jzc^DI~^a3C}%s zcp{sGF!7_|1wJ_>nqk;Oj48WcC=~1%ZZm`l>J@%`rALfQlw|xx4;d@ehn7H(FfdAO zI1Plk6W4G&6qttV5err02WX~ecxSsJh+8|#7-{T`1bz3%tn+Uc)(bwY$X5T_e|MN` zJeWjD6Q?_=O z_q=WH`H}NGv+;mkn?fL=ds#(Q6?oDUCxl(*jW|)PNrf}kDzf%8TSAh3_qbN*L)po2 z0qNJc%noBu>zdFoKh>D-#%Wf;E!T`7Inxk(=t`JRF)*+-lg`c@~v^DTTdBS%# m{t}d{OXd@};rQ5ziKiHpA^gpsqs!x`aI5SvuSRu!NB#k!H>T47 delta 558 zcmYjNL2DCH5bh+q+j$#fUnrQ3iEYFlLZMN&6hp*=h@gi?1hF>V-Ru@b3N^7L2koKF zK`V+N_<0h+gMXk}k0J_15kx!)#+!oPN{`}Ar*XkPc=Pe*ee=yX)7zxpCau?!*xJYV zmh{mwCQwV>#RN32rLn|C+_D4G7)@nIbZklO z!l>CF&HX5nt)7Tc1+F~5@izqZ0p4^1z2=ld8ky&(F9RZ5m|4^! rjUSC=bTS%EF}^MDwXlLqmTWaF;+5ong*{B!8t0^XhhvE1f3@mgg-WGP